@effect/language-service 0.58.3 → 0.59.0

package/README.md

@@ -72,6 +72,7 @@ And you're done! You'll now be able to use a set of refactors and diagnostics th
 - Warn when catch callbacks in `Effect.tryPromise`, `Effect.tryMap`, or `Effect.tryMapPromise` return `unknown` or `any` types
 - Warn when using `Effect.runSync`, `Effect.runPromise`, `Effect.runFork`, or `Effect.runCallback` inside an Effect
 - Warn when using `Schema.Union` with multiple `Schema.Literal` calls that can be simplified to a single `Schema.Literal` call
+- Suggest using `Schema.TaggedStruct` instead of `Schema.Struct` when a `_tag` field with `Schema.Literal` is present to make the tag optional in the constructor
 - Warn when using `yield* Effect.fail()` with yieldable error types that can be yielded directly
 
 ### Completions

package/cli.js

@@ -32065,7 +32065,16 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
         if (!moduleSymbol) continue;
         const memberSymbol = typeChecker.tryGetMemberInModuleExports(memberName, moduleSymbol);
-        if (memberSymbol && memberSymbol === symbol3) result.push({ memberSymbol, moduleSymbol, sourceFile });
+        if (memberSymbol) {
+          if (memberSymbol === symbol3) {
+            result.push({ memberSymbol, moduleSymbol, sourceFile });
+          } else if (memberSymbol.flags & ts.SymbolFlags.Alias) {
+            const aliased = typeChecker.getAliasedSymbol(memberSymbol);
+            if (aliased === symbol3) {
+              result.push({ memberSymbol, moduleSymbol, sourceFile });
+            }
+          }
+        }
       }
       if (result.length > 0) {
         return result;
@@ -32320,67 +32329,69 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.effectSubtype",
     (type2) => type2
   );
-  const importedContextModule = cachedBy(
-    fn2("TypeParser.importedContextModule")(function* (node) {
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an identifier", void 0, node);
-      }
-      const type2 = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type2, "Tag");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'Tag' property", type2, 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(
+    fn2("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(
+    fn2("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),
+      map34(() => node)
+    ),
     "TypeParser.importedContextModule",
     (node) => node
   );
-  const importedEffectModule = (node) => pipe(
-    isNodeReferenceToPackageModule(node, "effect", isEffectTypeSourceFile),
-    map34(() => node)
+  const importedEffectModule = cachedBy(
+    (node) => pipe(
+      isNodeReferenceToPackageModule(node, "effect", isEffectTypeSourceFile),
+      map34(() => node)
+    ),
+    "TypeParser.importedEffectModule",
+    (node) => node
   );
-  const importedDataModule = cachedBy(
-    fn2("TypeParser.importedDataModule")(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, "TaggedError");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'TaggedError' property", type2, 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 isEffectDataSourceFile = cachedBy(
+    fn2("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 isNodeReferenceToEffectDataModuleApi = (memberName) => cachedBy(
+    fn2("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),
+      map34(() => node)
+    ),
     "TypeParser.importedDataModule",
     (node) => node
   );
@@ -33119,6 +33130,8 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
+    isNodeReferenceToEffectDataModuleApi,
+    isNodeReferenceToEffectContextModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -33467,7 +33480,7 @@ var annotate3 = createCodegen({
         const initializerTypeNode = fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
           initializerType,
           enclosingNode,
-          ts.NodeBuilderFlags.NoTruncation
+          ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.IgnoreErrors
         )).pipe(
           getOrUndefined
         );
@@ -35671,6 +35684,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: fn2("schemaStructWithTag.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(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),
+          orElse14(() => void_8)
+        );
+        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
+                ),
+                option4
+              );
+              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: gen3(function* () {
+                        const changeTracker = yield* service2(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",
@@ -36362,7 +36454,8 @@ var diagnostics = [
   strictEffectProvide,
   unknownInEffectCatch,
   runEffectInsideEffect,
-  schemaUnionOfLiterals
+  schemaUnionOfLiterals,
+  schemaStructWithTag
 ];
 
 // src/cli/diagnostics.ts