@effect/language-service 0.15.0 → 0.16.0

package/README.md

@@ -26,12 +26,39 @@ This package implements a TypeScript language service plugin that allows additio
 
 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 +66,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 +89,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

@@ -1004,23 +1004,27 @@ var contextGet = (context, tag) => {
   }
   return none2();
 };
-var Nano = class {
-  constructor(run2) {
-    this.run = run2;
-  }
+var Proto = {
+  run: () => {
+  },
   [Symbol.iterator]() {
     return new SingleShotGen(new YieldWrap(this));
   }
 };
+function make3(run2) {
+  const result = Object.create(Proto);
+  result.run = run2;
+  return result;
+}
 var unsafeRun = (fa) => {
   const result = fa.run(contextEmpty);
   switch (result._tag) {
     case "Left":
-      return left2(result.left);
+      return left2(result.value);
     case "Defect":
-      return left2(new NanoDefectException(result.defect));
+      return left2(new NanoDefectException(result.value));
     case "Right":
-      return right2(result.right);
+      return right2(result.value);
   }
 };
 var run = (fa) => {
@@ -1030,35 +1034,35 @@ var run = (fa) => {
     return left2(new NanoDefectException(e));
   }
 };
-var succeed = (value) => new Nano(() => ({ _tag: "Right", right: value }));
-var fail = (value) => new Nano(() => ({ _tag: "Left", left: value }));
-var sync = (value) => new Nano(() => ({ _tag: "Right", right: value() }));
-var flatMap3 = dual(2, (fa, f) => new Nano((ctx) => {
+var succeed = (value) => make3(() => ({ _tag: "Right", value }));
+var fail = (value) => make3(() => ({ _tag: "Left", value }));
+var sync = (value) => make3(() => ({ _tag: "Right", value: value() }));
+var flatMap3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
-  return f(result.right).run(ctx);
+  return f(result.value).run(ctx);
 }));
-var map3 = dual(2, (fa, f) => new Nano((ctx) => {
+var map3 = dual(2, (fa, f) => make3((ctx) => {
   const result = fa.run(ctx);
   if (result._tag !== "Right") return result;
-  return { _tag: "Right", right: f(result.right) };
+  return { _tag: "Right", value: f(result.value) };
 }));
-var orElse3 = (f) => (fa) => new Nano((ctx) => {
+var orElse3 = (f) => (fa) => make3((ctx) => {
   const result = fa.run(ctx);
-  if (result._tag === "Left") return f(result.left).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 service = (tag) => new Nano(
+var service = (tag) => make3(
   (ctx) => contextGet(ctx, tag).pipe(match2({
-    onNone: () => ({ _tag: "Defect", defect: `Cannot find service ${tag.key}` }),
-    onSome: (value) => ({ _tag: "Right", right: value })
+    onNone: () => ({ _tag: "Defect", value: `Cannot find service ${tag.key}` }),
+    onSome: (value) => ({ _tag: "Right", value })
   }))
 );
-var provideService = (tag, value) => (fa) => new Nano((ctx) => {
+var provideService = (tag, value) => (fa) => make3((ctx) => {
   return fa.run(contextAdd(ctx, tag, value));
 });
-var gen2 = (...args) => new Nano((ctx) => {
+var gen2 = (...args) => make3((ctx) => {
   const iterator = args[0]();
   let state = iterator.next();
   while (!state.done) {
@@ -1067,11 +1071,11 @@ var gen2 = (...args) => new Nano((ctx) => {
     if (result._tag !== "Right") {
       return result;
     }
-    state = iterator.next(result.right);
+    state = iterator.next(result.value);
   }
-  return { _tag: "Right", right: state.value };
+  return { _tag: "Right", value: state.value };
 });
-var fn = (_) => (body) => (...args) => new Nano((ctx) => {
+var fn = (_) => (body) => (...args) => make3((ctx) => {
   const iterator = body(...args);
   let state = iterator.next();
   while (!state.done) {
@@ -1080,17 +1084,17 @@ var fn = (_) => (body) => (...args) => new Nano((ctx) => {
     if (result._tag !== "Right") {
       return result;
     }
-    state = iterator.next(result.right);
+    state = iterator.next(result.value);
   }
-  return { _tag: "Right", right: state.value };
+  return { _tag: "Right", value: state.value };
 });
-var option = (fa) => new Nano((ctx) => {
+var option = (fa) => make3((ctx) => {
   const result = fa.run(ctx);
   switch (result._tag) {
     case "Right":
-      return { _tag: "Right", right: some2(result.right) };
+      return { _tag: "Right", value: some2(result.value) };
     case "Left":
-      return { _tag: "Right", right: none2() };
+      return { _tag: "Right", value: none2() };
     case "Defect":
       return result;
   }
@@ -2610,6 +2614,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,
@@ -2635,21 +2640,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,
@@ -3595,6 +3612,7 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
           case "Date":
           case "Pick":
           case "Omit":
+          case "Record":
             return some2(name.text);
           case "ReadonlyArray":
           case "Array":
@@ -3631,8 +3649,17 @@ var parseAllLiterals = fn(
 )(
   function* (node) {
     const { ts } = yield* service(SchemaGenContext);
-    if (ts.isLiteralTypeNode(node) && node.literal.kind === ts.SyntaxKind.StringLiteral) {
-      return [ts.factory.createStringLiteral(node.literal.text)];
+    if (ts.isLiteralTypeNode(node)) {
+      switch (node.literal.kind) {
+        case ts.SyntaxKind.StringLiteral:
+          return [ts.factory.createStringLiteral(node.literal.text)];
+        case ts.SyntaxKind.NumericLiteral:
+          return [ts.factory.createNumericLiteral(node.literal.text)];
+        case ts.SyntaxKind.TrueKeyword:
+          return [ts.factory.createTrue()];
+        case ts.SyntaxKind.FalseKeyword:
+          return [ts.factory.createFalse()];
+      }
     }
     if (ts.isUnionTypeNode(node)) {
       return flatten(yield* all2(...node.types.map((_) => parseAllLiterals(_))));
@@ -3675,23 +3702,30 @@ var processNode = (node) => gen2(function* () {
       return createApiPropertyAccess("BigInt");
   }
   if (ts.isLiteralTypeNode(node)) {
-    switch (node.literal.kind) {
-      case ts.SyntaxKind.NullKeyword:
-        return createApiPropertyAccess("Null");
-      case ts.SyntaxKind.TrueKeyword:
-        return createApiCall("Literal", [ts.factory.createTrue()]);
-      case ts.SyntaxKind.FalseKeyword:
-        return createApiCall("Literal", [ts.factory.createFalse()]);
-      case ts.SyntaxKind.StringLiteral:
-        return createApiCall("Literal", [ts.factory.createStringLiteral(node.literal.text)]);
-      case ts.SyntaxKind.NumericLiteral:
-        return createApiCall("Literal", [ts.factory.createNumericLiteral(node.literal.text)]);
-    }
+    if (node.literal.kind === ts.SyntaxKind.NullKeyword) return createApiPropertyAccess("Null");
+    const literalMembers = yield* option(parseAllLiterals(node));
+    if (isSome2(literalMembers)) return createApiCall("Literal", literalMembers.value);
   }
   if (ts.isUnionTypeNode(node)) {
+    const allLiterals = yield* option(parseAllLiterals(node));
+    if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
     const members = yield* all2(...node.types.map((_) => processNode(_)));
     return createApiCall("Union", members);
   }
+  if (ts.isIntersectionTypeNode(node)) {
+    const [firstSchema, ...otherSchemas] = yield* all2(
+      ...node.types.map((_) => processNode(_))
+    );
+    if (otherSchemas.length === 0) return firstSchema;
+    return ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        firstSchema,
+        "pipe"
+      ),
+      [],
+      otherSchemas.map((_) => createApiCall("extend", [_]))
+    );
+  }
   if (ts.isArrayTypeNode(node)) {
     const typeSchema = yield* processNode(node.elementType);
     return createApiCall("Array", [typeSchema]);
@@ -3718,6 +3752,20 @@ var processNode = (node) => gen2(function* () {
           );
           return createApiCall(parsedName.value, elements);
         }
+        case "Record": {
+          const elements = yield* all2(
+            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+          );
+          if (elements.length >= 2) {
+            return createApiCall(parsedName.value, [
+              ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment("key", elements[0]),
+                ts.factory.createPropertyAssignment("value", elements[1])
+              ])
+            ]);
+          }
+          return createUnsupportedNodeComment(ts, sourceFile, node);
+        }
         case "Either": {
           const elements = yield* all2(
             ...node.typeArguments ? node.typeArguments.map(processNode) : []
@@ -4252,7 +4300,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) {