@effect/language-service 0.15.1 → 0.16.1

package/README.md

@@ -23,15 +23,43 @@ This package implements a TypeScript language service plugin that allows additio
 
    - In VSCode you can do this by pressing "F1" and typing "TypeScript: Select TypeScript version". Then select "Use workspace version".
    - In JetBrains you may have to disable the Vue language service, and chose the workspace version of TypeScript in the settings from the dropdown.
+   - In NVim with nvim-vtsls you should refer to [how to enable TypeScript plugins in vstls](https://github.com/yioneko/vtsls?tab=readme-ov-file#typescript-plugin-not-activated)
 
 And you're done! You'll now be able to use a set of refactor and diagnostics that targets Effect!
 
-## Enable diagnostics at compile time
+## Provided functionalities
 
-TypeScript LSP are loaded only while editing your files. That means that if you run `tsc` in your project, the plugin won't be loaded and you'll miss out on the Effect diagnostics.
+### Quickinfo
 
-HOWEVER, if you use `ts-patch` you can enable the transform as well to get the diagnostics also at compile time.
-Your `tsconfig.json` should look like this:
+- Show the extended type of the current Effect
+- Hovering yield\* of Effect.gen will show the Effect type parameters
+
+### Diagnostics
+
+- Better error readability when you're missing errors or service types in your Effect definitions
+- Floating Effects that are not yielded or run
+- Wrong usage of yield inside Effect.gen
+- Unnecessary usages of Effect.gen
+- Multiple versions of Effect in your project
+
+### Completions
+
+- Autocomplete 'Self' in Effect.Service, Context.Tag, Schema.TaggedClass, Schema.TaggedRequest and family
+
+### Refactors
+
+- Transform an async function definition, into an Effect by using Effect.gen.
+- Transform an async function definition, into an Effect by using Effect.gen, and generating a tagged error for each promise call.
+- Transform a function returning an Effect.gen into a Effect.fn
+- Function calls to pipe: Transform a set of function calls to a pipe() call.
+- Pipe to datafirst: Transform a pipe() call into a series of datafirst function calls (where available).
+- Toggle return type signature: With a single refactor, adds or removes type annotations from the definition.
+- Remove unnecessary `Effect.gen` definitions that contains a single `yield` statement.
+- Wrap an `Effect` expression with `Effect.gen`
+
+## Options
+
+Few options can be provided alongside the initialization of the Language Service Plugin.
 
 ```json
 {
@@ -39,30 +67,22 @@ Your `tsconfig.json` should look like this:
     "plugins": [
       {
         "name": "@effect/language-service",
-        "transform": "@effect/language-service/transform" // enables diagnostics at compile time when using ts-patch
+        "diagnostics": true, // controls Effect diagnostics (default: true)
+        "quickinfo": true, // controls quickinfo over Effect (default: true)
+        "completions": true, // controls Effect completions (default: true)
+        "multipleEffectCheck": true // controls if multiple versions of Effect are referenced (default: true)
       }
     ]
   }
 }
 ```
 
-To get diagnostics you need to install `ts-patch` which will make it possible to run `tspc`.
-
-Running `tspc` in your project will now also run the plugin and give you the diagnostics at compile time.
-
-```ts
-$ npx tspc
-index.ts:3:1 - error TS3: Effect must be yielded or assigned to a variable.
-
-3 Effect.succeed(1)
-  ~~~~~~~~~~~~~~~~~
-
-Found 1 error in index.ts:3 
-```
+## Why diagnostics does not appear at compile time?
 
-## Options
+TypeScript LSP are loaded only while editing your files. That means that if you run `tsc` in your project, the plugin won't be loaded and you'll miss out on the Effect diagnostics.
 
-Few options can be provided alongside the initialization of the Language Service Plugin.
+HOWEVER, if you use `ts-patch` you can enable the transform as well to get the diagnostics also at compile time.
+Your `tsconfig.json` should look like this:
 
 ```json
 {
@@ -70,44 +90,27 @@ Few options can be provided alongside the initialization of the Language Service
     "plugins": [
       {
         "name": "@effect/language-service",
-        "diagnostics": true, // controls Effect diagnostics
-        "quickinfo": true, // controls quickinfo over Effect
-        "completions": true, // controls Effect completions
-        "multipleEffectCheck": true // controls if multiple versions of Effect are referenced
+        "transform": "@effect/language-service/transform" // enables diagnostics at compile time when using ts-patch
       }
     ]
   }
 }
 ```
 
-## Provided functionalities
-
-### Quickinfo
-
-- Show the extended type of the current Effect
-
-### Diagnostics
-
-- Better error readability when you're missing errors or service types in your Effect definitions
-- Floating Effects that are not yielded or run
-- Wrong usage of yield inside Effect.gen
-- Unnecessary usages of Effect.gen
-- Multiple versions of Effect in your project
+To get diagnostics you need to install `ts-patch` which will make it possible to run `tspc`.
 
-### Completions
+Running `tspc` in your project will now also run the plugin and give you the diagnostics at compile time.
+Effect diagnostics will be shown only after standard TypeScript diagnostics has been satisfied.
 
-- Autocomplete 'Self' in Effect.Service, Context.Tag, Schema.TaggedClass, Schema.TaggedRequest and family
+```ts
+$ npx tspc
+index.ts:3:1 - error TS3: Effect must be yielded or assigned to a variable.
 
-### Refactors
+3 Effect.succeed(1)
+  ~~~~~~~~~~~~~~~~~
 
-- Transform an async function definition, into an Effect by using Effect.gen.
-- Transform an async function definition, into an Effect by using Effect.gen, and generating a tagged error for each promise call.
-- Transform a function returning an Effect.gen into a Effect.fn
-- Function calls to pipe: Transform a set of function calls to a pipe() call.
-- Pipe to datafirst: Transform a pipe() call into a series of datafirst function calls (where available).
-- Toggle return type signature: With a single refactor, adds or removes type annotations from the definition.
-- Remove unnecessary `Effect.gen` definitions that contains a single `yield` statement.
-- Wrap an `Effect` expression with `Effect.gen`
+Found 1 error in index.ts:3 
+```
 
 ## Configuring diagnostics
 

package/index.js

@@ -961,7 +961,6 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return out;
 });
-var reduce = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable(self).reduce((b2, a, i) => f(b2, a, i), b));
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
   if (isNonEmptyReadonlyArray(input)) {
@@ -978,6 +977,30 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 });
 
 // src/core/Nano.ts
+var NanoInternalSuccessProto = {
+  _tag: "Right"
+};
+function makeInternalSuccess(value) {
+  const result = Object.create(NanoInternalSuccessProto);
+  result.value = value;
+  return result;
+}
+var NanoInternalFailureProto = {
+  _tag: "Left"
+};
+function makeInternalFailure(value) {
+  const result = Object.create(NanoInternalFailureProto);
+  result.value = value;
+  return result;
+}
+var NanoInternalDefectProto = {
+  _tag: "Defect"
+};
+function makeInternalDefect(value) {
+  const result = Object.create(NanoInternalDefectProto);
+  result.value = value;
+  return result;
+}
 var NanoDefectException = class {
   constructor(message) {
     this.message = message;
@@ -991,19 +1014,6 @@ var NanoTag = class {
 };
 var Tag = (identifier) => new NanoTag(identifier);
 var contextEmpty = { value: {} };
-var contextAdd = (context, tag, value) => ({
-  ...context,
-  value: {
-    ...context.value,
-    [tag.key]: value
-  }
-});
-var contextGet = (context, tag) => {
-  if (tag.key in context.value) {
-    return some2(context.value[tag.key]);
-  }
-  return none2();
-};
 var Proto = {
   run: () => {
   },
@@ -1034,9 +1044,9 @@ var run = (fa) => {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => make3(() => ({ _tag: "Right", value }));
-var fail = (value) => make3(() => ({ _tag: "Left", value }));
-var sync = (value) => make3(() => ({ _tag: "Right", value: value() }));
+var succeed = (value) => make3(() => makeInternalSuccess(value));
+var fail = (value) => make3(() => makeInternalFailure(value));
+var sync = (value) => make3(() => makeInternalSuccess(value()));
 var flatMap3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
@@ -1045,22 +1055,25 @@ var flatMap3 = dual(2, (fa, f) => make3((ctx) => {
 var map3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
-  return { _tag: "Right", value: f(result.value) };
+  return makeInternalSuccess(f(result.value));
 }));
 var orElse3 = (f) => (fa) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag === "Left") return f(result.value).run(ctx);
   return result;
 });
-var firstSuccessOf = (arr) => reduce(arr.slice(1), arr[0], (arr2, fa) => orElse3(() => fa)(arr2));
+var firstSuccessOf = (arr) => arr.slice(1).reduce((arr2, fa) => orElse3(() => fa)(arr2), arr[0]);
 var service = (tag) => make3(
-  (ctx) => contextGet(ctx, tag).pipe(match2({
-    onNone: () => ({ _tag: "Defect", value: `Cannot find service ${tag.key}` }),
-    onSome: (value) => ({ _tag: "Right", value })
-  }))
+  (ctx) => tag.key in ctx.value ? makeInternalSuccess(ctx.value[tag.key]) : makeInternalDefect(`Cannot find service ${tag.key}`)
 );
 var provideService = (tag, value) => (fa) => make3((ctx) => {
-  return fa.run(contextAdd(ctx, tag, value));
+  return fa.run({
+    ...ctx,
+    value: {
+      ...ctx.value,
+      [tag.key]: value
+    }
+  });
 });
 var gen2 = (...args) => make3((ctx) => {
   const iterator = args[0]();
@@ -1073,7 +1086,7 @@ var gen2 = (...args) => make3((ctx) => {
     }
     state = iterator.next(result.value);
   }
-  return { _tag: "Right", value: state.value };
+  return makeInternalSuccess(state.value);
 });
 var fn = (_) => (body) => (...args) => make3((ctx) => {
   const iterator = body(...args);
@@ -1086,15 +1099,15 @@ var fn = (_) => (body) => (...args) => make3((ctx) => {
     }
     state = iterator.next(result.value);
   }
-  return { _tag: "Right", value: state.value };
+  return makeInternalSuccess(state.value);
 });
 var option = (fa) => make3((ctx) => {
   const result = fa.run(ctx);
   switch (result._tag) {
     case "Right":
-      return { _tag: "Right", value: some2(result.value) };
+      return makeInternalSuccess(some2(result.value));
     case "Left":
-      return { _tag: "Right", value: none2() };
+      return makeInternalSuccess(none2());
     case "Defect":
       return result;
   }
@@ -1468,7 +1481,9 @@ function createCompletion(definition) {
   return definition;
 }
 var PluginOptions = Tag("PluginOptions");
-var getSemanticDiagnosticsWithCodeFixes = fn("LSP.getSemanticDiagnostics")(function* (rules, sourceFile) {
+var getSemanticDiagnosticsWithCodeFixes = fn(
+  "LSP.getSemanticDiagnosticsWithCodeFixes"
+)(function* (rules, sourceFile) {
   const effectDiagnostics = [];
   const effectCodeFixes = [];
   const executor = yield* createDiagnosticExecutor(sourceFile);
@@ -2570,9 +2585,7 @@ var unnecessaryEffectGen = createDiagnostic({
         option
       );
       if (isSome2(maybeNode)) {
-        if (isSome2(maybeNode)) {
-          unnecessaryGenerators.set(node, maybeNode.value);
-        }
+        unnecessaryGenerators.set(node, maybeNode.value);
       }
     }
     unnecessaryGenerators.forEach(
@@ -2614,6 +2627,7 @@ var JSDocTagInfoEq = make(
   (fa, fb) => fa.name === fb.name && typeof fa.text === typeof fb.text && (typeof fa.text !== "undefined" ? array(SymbolDisplayPartEq)(fa.text, fb.text) : true)
 );
 function dedupeJsDocTags(quickInfo) {
+  if (!quickInfo) return quickInfo;
   if (quickInfo.tags) {
     return {
       ...quickInfo,
@@ -2639,21 +2653,33 @@ function prependEffectTypeArguments(sourceFile, position, quickInfo) {
     gen2(function* () {
       const ts = yield* service(TypeScriptApi);
       const typeChecker = yield* service(TypeCheckerApi);
-      const hasTruncationHappened = ts.displayPartsToString(quickInfo.displayParts).indexOf("...") > -1;
-      if (!hasTruncationHappened) return quickInfo;
       const maybeNode = pipe(
         yield* getAncestorNodesInRange(sourceFile, toTextRange(position)),
         head
       );
       if (isNone2(maybeNode)) return quickInfo;
+      const node = maybeNode.value;
+      const hasTruncationHappened = quickInfo && ts.displayPartsToString(quickInfo.displayParts).indexOf("...") > -1;
+      const nodeForType = !quickInfo && ts.isYieldExpression(node) && node.asteriskToken && node.expression ? node.expression : hasTruncationHappened ? node : void 0;
+      if (!nodeForType) return quickInfo;
       const effectType2 = yield* effectType(
-        typeChecker.getTypeAtLocation(maybeNode.value),
-        maybeNode.value
+        typeChecker.getTypeAtLocation(nodeForType),
+        nodeForType
       );
       const effectTypeArgsDocumentation = [{
         kind: "text",
         text: "```ts\n/* Effect Type Parameters */\n" + (yield* formatTypeForQuickInfo(effectType2.A, "Success")) + "\n" + (yield* formatTypeForQuickInfo(effectType2.E, "Failure")) + "\n" + (yield* formatTypeForQuickInfo(effectType2.R, "Requirements")) + "\n```\n"
       }];
+      if (!quickInfo) {
+        const start = node.getStart();
+        const end = node.getEnd();
+        return {
+          kind: ts.ScriptElementKind.callSignatureElement,
+          kindModifiers: "",
+          textSpan: { start, length: end - start },
+          documentation: effectTypeArgsDocumentation
+        };
+      }
       if (quickInfo.documentation) {
         return {
           ...quickInfo,
@@ -4287,7 +4313,7 @@ var init = (modules) => {
     };
     proxy.getQuickInfoAtPosition = (fileName, position, ...args) => {
       const quickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
-      if (pluginOptions.quickinfo && quickInfo) {
+      if (pluginOptions.quickinfo) {
         const dedupedTagsQuickInfo = dedupeJsDocTags(quickInfo);
         const program = languageService.getProgram();
         if (program) {