@effect/language-service 0.8.0 → 0.8.1

package/index.js

@@ -954,6 +954,18 @@ var sort = /* @__PURE__ */ dual(2, (self, O) => {
 });
 var empty = () => [];
 var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var filterMap = /* @__PURE__ */ dual(2, (self, f) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0; i < as.length; i++) {
+    const o = f(as[i], i);
+    if (isSome2(o)) {
+      out.push(o.value);
+    }
+  }
+  return out;
+});
+var getSomes = /* @__PURE__ */ filterMap(identity);
 var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
@@ -2789,6 +2801,28 @@ function getSemanticDiagnostics(diagnostics2, sourceFile) {
     return effectDiagnostics;
   });
 }
+function getCodeFixesAtPosition(diagnostics2, sourceFile, start, end, errorCodes) {
+  return gen2(function* () {
+    const runnableDiagnostics = diagnostics2.filter((_) => errorCodes.indexOf(_.code) > -1);
+    const applicableFixes = [];
+    for (const diagnostic of runnableDiagnostics) {
+      const result = yield* option(diagnostic.apply(sourceFile));
+      if (isSome2(result)) {
+        applicableFixes.push(
+          ...pipe(
+            result.value,
+            filter(
+              (_) => _.node.getStart(sourceFile) === start && _.node.getEnd() === end
+            ),
+            map2((_) => _.fix),
+            getSomes
+          )
+        );
+      }
+    }
+    return applicableFixes;
+  });
+}
 function getApplicableRefactors(refactors2, sourceFile, positionOrRange) {
   return gen2(function* () {
     const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
@@ -3270,7 +3304,8 @@ var floatingEffect = createDiagnostic({
           effectDiagnostics.push({
             node,
             category: ts.DiagnosticCategory.Error,
-            messageText: `Effect must be yielded or assigned to a variable.`
+            messageText: `Effect must be yielded or assigned to a variable.`,
+            fix: none2()
           });
         }
       }
@@ -3330,7 +3365,8 @@ var missingEffectContext = createDiagnostic({
             {
               node: node2,
               category: ts.DiagnosticCategory.Error,
-              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`
+              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect context.`,
+              fix: none2()
             }
           );
         }
@@ -3391,7 +3427,8 @@ var missingEffectError = createDiagnostic({
             {
               node: node2,
               category: ts.DiagnosticCategory.Error,
-              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`
+              messageText: `Missing '${sortTypes(missingContext).map((_) => typeChecker.typeToString(_)).join(" | ")}' in the expected Effect errors.`,
+              fix: none2()
             }
           );
         }
@@ -3448,16 +3485,33 @@ var missingStarInYieldEffectGen = createDiagnostic({
       (node) => effectDiagnostics.push({
         node,
         category: ts.DiagnosticCategory.Error,
-        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`
+        messageText: `Seems like you used yield instead of yield* inside this Effect.gen.`,
+        fix: none2()
       })
     );
-    brokenYields.forEach(
-      (node) => effectDiagnostics.push({
+    brokenYields.forEach((node) => {
+      const fix = node.expression ? some2({
+        fixName: "missingStarInYieldEffectGen_fix",
+        description: "Replace yield with yield*",
+        apply: gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node,
+            ts.factory.createYieldExpression(
+              ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+              node.expression
+            )
+          );
+        })
+      }) : none2();
+      effectDiagnostics.push({
         node,
         category: ts.DiagnosticCategory.Error,
-        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`
-      })
-    );
+        messageText: `When yielding Effects inside Effect.gen, you should use yield* instead of yield.`,
+        fix
+      });
+    });
     return effectDiagnostics;
   })
 });
@@ -3469,7 +3523,7 @@ var unnecessaryEffectGen = createDiagnostic({
   apply: (sourceFile) => gen2(function* () {
     const ts = yield* service(TypeScriptApi);
     const effectDiagnostics = [];
-    const brokenGenerators = /* @__PURE__ */ new Set();
+    const unnecessaryGenerators = /* @__PURE__ */ new Map();
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -3485,14 +3539,24 @@ var unnecessaryEffectGen = createDiagnostic({
         option
       );
       if (isSome2(maybeUnnecessaryGen)) {
-        brokenGenerators.add(node);
+        unnecessaryGenerators.set(node, maybeUnnecessaryGen.value);
       }
     }
-    brokenGenerators.forEach(
-      (node) => effectDiagnostics.push({
+    unnecessaryGenerators.forEach(
+      (body, node) => effectDiagnostics.push({
         node,
         category: ts.DiagnosticCategory.Suggestion,
-        messageText: `This Effect.gen is useless here because it only contains a single return statement.`
+        messageText: `This Effect.gen is useless here because it only contains a single return statement.`,
+        fix: some2({
+          fixName: "unnecessaryEffectGen_fix",
+          description: "Remove the Effect.gen, and keep the body",
+          apply: gen2(function* () {
+            const textChanges = yield* service(
+              ChangeTracker
+            );
+            textChanges.replaceNode(sourceFile, node, body);
+          })
+        })
       })
     );
     return effectDiagnostics;
@@ -3677,10 +3741,17 @@ function findImportedModuleIdentifier(sourceFile, test) {
       const namedBindings = importClause.namedBindings;
       if (!namedBindings) continue;
       if (ts.isNamespaceImport(namedBindings)) {
-        if (yield* test(namedBindings.name)) return namedBindings.name;
+        if (yield* test(namedBindings.name, statement.moduleSpecifier, none2())) {
+          return namedBindings.name;
+        }
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
-          if (yield* test(importSpecifier.name)) return importSpecifier.name;
+          const importProperty = fromNullable2(importSpecifier.propertyName).pipe(
+            orElse2(() => some2(importSpecifier.name))
+          );
+          if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
+            return importSpecifier.name;
+          }
         }
       }
     }
@@ -4430,9 +4501,81 @@ var init = (modules) => {
       quickinfo: info.config && "quickinfo" in info.config && typeof info.config.quickinfo === "boolean" ? info.config.quickinfo : true
     };
     const proxy = /* @__PURE__ */ Object.create(null);
-    for (const k of Object.keys(info.languageService)) {
+    for (const k of Object.keys(languageService)) {
       proxy[k] = (...args) => languageService[k].apply(languageService, args);
     }
+    const diagnosticsErrorCodes = diagnostics.map((diagnostic) => diagnostic.code);
+    try {
+      ;
+      modules.typescript.codefix.registerCodeFix({
+        errorCodes: diagnosticsErrorCodes,
+        getCodeActions: () => void 0
+      });
+    } catch (_) {
+    }
+    proxy.getSupportedCodeFixes = (...args) => languageService.getSupportedCodeFixes(...args).concat(
+      diagnosticsErrorCodes.map((_) => "" + _)
+    );
+    proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences, ...args) => {
+      const applicableCodeFixes = languageService.getCodeFixesAtPosition(
+        fileName,
+        start,
+        end,
+        errorCodes,
+        formatOptions,
+        preferences,
+        ...args
+      );
+      const program = languageService.getProgram();
+      if (program) {
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+          return pipe(
+            gen2(function* () {
+              const effectCodeFixes = [];
+              const applicableFixes = yield* getCodeFixesAtPosition(
+                diagnostics,
+                sourceFile,
+                start,
+                end,
+                errorCodes
+              );
+              const formatContext = modules.typescript.formatting.getFormatContext(
+                formatOptions,
+                info.languageServiceHost
+              );
+              for (const applicableFix of applicableFixes) {
+                const changes = modules.typescript.textChanges.ChangeTracker.with(
+                  {
+                    formatContext,
+                    host: info.languageServiceHost,
+                    preferences: preferences || {}
+                  },
+                  (changeTracker) => pipe(
+                    applicableFix.apply,
+                    provideService(ChangeTracker, changeTracker),
+                    run
+                  )
+                );
+                effectCodeFixes.push({
+                  fixName: applicableFix.fixName,
+                  description: applicableFix.description,
+                  changes
+                });
+              }
+              return effectCodeFixes;
+            }),
+            provideService(TypeScriptApi, modules.typescript),
+            provideService(TypeCheckerApi, program.getTypeChecker()),
+            provideService(PluginOptions, pluginOptions),
+            run,
+            Either_exports.map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
+            Either_exports.getOrElse(() => applicableCodeFixes)
+          );
+        }
+      }
+      return applicableCodeFixes;
+    };
     proxy.getSemanticDiagnostics = (fileName, ...args) => {
       const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
       const program = languageService.getProgram();