@effect/language-service 0.10.0 → 0.10.1

package/index.js

@@ -3112,11 +3112,12 @@ function createCompletion(definition) {
 var PluginOptions = Tag("PluginOptions");
 var SourceFileNotFoundError = class extends TaggedError("SourceFileNotFoundError") {
 };
-var getSemanticDiagnostics = fn("LSP.getSemanticDiagnostics")(function* (diagnostics2, sourceFile) {
+var getSemanticDiagnosticsWithCodeFixes = fn("LSP.getSemanticDiagnostics")(function* (rules, sourceFile) {
   const effectDiagnostics = [];
+  const effectCodeFixes = [];
   const executor = yield* createDiagnosticExecutor(sourceFile);
-  for (const diagnostic of diagnostics2) {
-    const result = yield* option(executor.execute(diagnostic));
+  for (const rule of rules) {
+    const result = yield* option(executor.execute(rule));
     if (isSome2(result)) {
       effectDiagnostics.push(
         ...pipe(
@@ -3127,35 +3128,34 @@ var getSemanticDiagnostics = fn("LSP.getSemanticDiagnostics")(function* (diagnos
             length: _.node.getEnd() - _.node.getStart(sourceFile),
             messageText: _.messageText,
             category: _.category,
-            code: diagnostic.code,
+            code: rule.code,
             source: "effect"
           }))
         )
       );
-    }
-  }
-  return effectDiagnostics;
-});
-var getCodeFixesAtPosition = fn("LSP.getCodeFixesAtPosition")(function* (diagnostics2, sourceFile, start, end, errorCodes) {
-  const runnableDiagnostics = diagnostics2.filter((_) => errorCodes.indexOf(_.code) > -1);
-  const applicableFixes = [];
-  const executor = yield* createDiagnosticExecutor(sourceFile);
-  for (const diagnostic of runnableDiagnostics) {
-    const result = yield* option(executor.execute(diagnostic));
-    if (isSome2(result)) {
-      applicableFixes.push(
+      effectCodeFixes.push(
         ...pipe(
           result.value,
-          filter(
-            (_) => _.node.getStart(sourceFile) === start && _.node.getEnd() === end
+          map2(
+            (_) => map2(
+              _.fixes,
+              (fix) => ({
+                ...fix,
+                code: rule.code,
+                start: _.node.getStart(sourceFile),
+                end: _.node.getEnd()
+              })
+            )
           ),
-          map2((_) => _.fixes),
           flatten
         )
       );
     }
   }
-  return applicableFixes;
+  return {
+    diagnostics: effectDiagnostics,
+    codeFixes: effectCodeFixes
+  };
 });
 var getApplicableRefactors = fn("LSP.getApplicableRefactors")(function* (refactors2, sourceFile, positionOrRange) {
   const textRange = typeof positionOrRange === "number" ? { pos: positionOrRange, end: positionOrRange } : positionOrRange;
@@ -4813,10 +4813,6 @@ var init = (modules) => {
       quickinfo: info.config && "quickinfo" in info.config && typeof info.config.quickinfo === "boolean" ? info.config.quickinfo : true,
       completions: info.config && "completions" in info.config && typeof info.config.completions === "boolean" ? info.config.completions : true
     };
-    const proxy = /* @__PURE__ */ Object.create(null);
-    for (const k of Object.keys(languageService)) {
-      proxy[k] = (...args) => languageService[k].apply(languageService, args);
-    }
     const diagnosticsErrorCodes = diagnostics.map((diagnostic) => diagnostic.code);
     try {
       ;
@@ -4826,81 +4822,20 @@ var init = (modules) => {
       });
     } 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(TypeCheckerApi, program.getTypeChecker()),
-            provideService(
-              TypeCheckerApiCache,
-              makeTypeCheckerApiCache()
-            ),
-            provideService(TypeScriptApi, modules.typescript),
-            provideService(PluginOptions, pluginOptions),
-            run,
-            Either_exports.map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
-            Either_exports.getOrElse(() => applicableCodeFixes)
-          );
-        }
-      }
-      return applicableCodeFixes;
-    };
+    const proxy = /* @__PURE__ */ Object.create(null);
+    for (const k of Object.keys(languageService)) {
+      proxy[k] = (...args) => languageService[k].apply(languageService, args);
+    }
+    const effectCodeFixesForFile = /* @__PURE__ */ new Map();
     proxy.getSemanticDiagnostics = (fileName, ...args) => {
       const applicableDiagnostics = languageService.getSemanticDiagnostics(fileName, ...args);
       const program = languageService.getProgram();
       if (pluginOptions.diagnostics && program) {
+        effectCodeFixesForFile.delete(fileName);
         const sourceFile = program.getSourceFile(fileName);
         if (sourceFile) {
           return pipe(
-            getSemanticDiagnostics(diagnostics, sourceFile),
+            getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
             provideService(TypeCheckerApi, program.getTypeChecker()),
             provideService(
               TypeCheckerApiCache,
@@ -4909,13 +4844,65 @@ var init = (modules) => {
             provideService(TypeScriptApi, modules.typescript),
             provideService(PluginOptions, pluginOptions),
             run,
-            Either_exports.map((effectDiagnostics) => effectDiagnostics.concat(applicableDiagnostics)),
+            Either_exports.map(({ codeFixes, diagnostics: diagnostics2 }) => {
+              effectCodeFixesForFile.set(fileName, codeFixes);
+              return diagnostics2.concat(applicableDiagnostics);
+            }),
             Either_exports.getOrElse(() => applicableDiagnostics)
           );
         }
       }
       return applicableDiagnostics;
     };
+    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
+      );
+      return pipe(
+        sync(() => {
+          const effectCodeFixes = [];
+          const applicableFixes = (effectCodeFixesForFile.get(fileName) || []).filter(
+            (_) => _.start === start && _.end === end && errorCodes.indexOf(_.code) > -1
+          );
+          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;
+        }),
+        run,
+        Either_exports.map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
+        Either_exports.getOrElse(() => applicableCodeFixes)
+      );
+    };
     proxy.getApplicableRefactors = (...args) => {
       const applicableRefactors = languageService.getApplicableRefactors(...args);
       const [fileName, positionOrRange] = args;