@effect/language-service 0.4.0 → 0.5.1

package/index.js

@@ -64,6 +64,8 @@ var dual = function(arity, body) {
   }
 };
 var identity = (a) => a;
+var constant = (value) => () => value;
+var constUndefined = /* @__PURE__ */ constant(void 0);
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
     case 1:
@@ -649,6 +651,7 @@ var isSome2 = isSome;
 var getOrElse = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
 var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
+var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
 var map = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
 var all = (input) => {
@@ -1434,12 +1437,47 @@ var missingStarInYieldEffectGen = createDiagnostic({
   }
 });
 
+// src/diagnostics/unnecessaryEffectGen.ts
+var unnecessaryEffectGen = createDiagnostic({
+  code: 5,
+  apply: (ts, program) => (sourceFile) => {
+    const typeChecker = program.getTypeChecker();
+    const effectDiagnostics = [];
+    const brokenGenerators = /* @__PURE__ */ new Set();
+    const visit = (node) => {
+      const effectGenLike = effectGen(ts, typeChecker)(node);
+      if (isSome2(effectGenLike)) {
+        const body = effectGenLike.value.body;
+        if (body.statements.length === 1 && ts.isReturnStatement(body.statements[0]) && body.statements[0].expression && ts.isYieldExpression(body.statements[0].expression) && body.statements[0].expression.expression) {
+          const nodeToCheck = body.statements[0].expression.expression;
+          const type = typeChecker.getTypeAtLocation(nodeToCheck);
+          const maybeEffect = effectType(ts, typeChecker)(type, nodeToCheck);
+          if (isSome2(maybeEffect)) {
+            brokenGenerators.add(node);
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    ts.forEachChild(sourceFile, visit);
+    brokenGenerators.forEach(
+      (node) => effectDiagnostics.push({
+        node,
+        category: ts.DiagnosticCategory.Warning,
+        messageText: `This Effect.gen is useless here because it only contains a single return statement.`
+      })
+    );
+    return effectDiagnostics;
+  }
+});
+
 // src/diagnostics.ts
 var diagnostics = {
   missingEffectContext,
   missingEffectError,
   floatingEffect,
-  missingStarInYieldEffectGen
+  missingStarInYieldEffectGen,
+  unnecessaryEffectGen
 };
 
 // src/quickinfo.ts
@@ -1458,6 +1496,47 @@ function dedupeJsDocTags(quickInfo) {
   }
   return quickInfo;
 }
+function formatTypeForQuickInfo(ts, typeChecker) {
+  return (channelType, channelName) => {
+    const stringRepresentation = typeChecker.typeToString(
+      channelType,
+      void 0,
+      ts.TypeFormatFlags.NoTruncation
+    );
+    return `type ${channelName} = ${stringRepresentation}`;
+  };
+}
+function prependEffectTypeArguments(ts, program) {
+  return (sourceFileName, position, quickInfo) => {
+    const sourceFile = program.getSourceFile(sourceFileName);
+    if (!sourceFile) return quickInfo;
+    const hasTruncationHappened = ts.displayPartsToString(quickInfo.displayParts).indexOf("...") > -1;
+    if (!hasTruncationHappened) return quickInfo;
+    const typeChecker = program.getTypeChecker();
+    const effectTypeArgsDocumentation = pipe(
+      getNodesContainingRange(ts)(sourceFile, toTextRange(position)),
+      head,
+      flatMap(
+        (_) => effectType(ts, typeChecker)(typeChecker.getTypeAtLocation(_), _)
+      ),
+      map((_) => [{
+        kind: "text",
+        text: "```ts\n/* Effect Type Parameters */\n" + formatTypeForQuickInfo(ts, typeChecker)(_.A, "Success") + "\n" + formatTypeForQuickInfo(ts, typeChecker)(_.E, "Failure") + "\n" + formatTypeForQuickInfo(ts, typeChecker)(_.R, "Requirements") + "\n```\n"
+      }]),
+      getOrElse(() => [])
+    );
+    if (quickInfo.documentation) {
+      return {
+        ...quickInfo,
+        documentation: effectTypeArgsDocumentation.concat(quickInfo.documentation)
+      };
+    }
+    return {
+      ...quickInfo,
+      documentation: effectTypeArgsDocumentation
+    };
+  };
+}
 
 // src/refactors/asyncAwaitToGen.ts
 var asyncAwaitToGen = createRefactor({
@@ -1800,7 +1879,9 @@ var toggleTypeAnnotation = createRefactor({
   description: "Toggle type annotation",
   apply: (ts, program) => (sourceFile, textRange) => pipe(
     getNodesContainingRange(ts)(sourceFile, textRange),
-    filter(ts.isVariableDeclaration),
+    filter(
+      (node) => ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node)
+    ),
     filter((node) => isNodeInRange(textRange)(node.name)),
     filter((node) => !!node.initializer),
     head,
@@ -1816,10 +1897,19 @@ var toggleTypeAnnotation = createRefactor({
           }
           const initializer = node.initializer;
           const initializerType = typeChecker.getTypeAtLocation(initializer);
-          const initializerTypeNode = typeChecker.typeToTypeNode(
+          const initializerTypeNode = fromNullable(typeChecker.typeToTypeNode(
             initializerType,
             node,
             ts.NodeBuilderFlags.NoTruncation
+          )).pipe(
+            orElse(
+              () => fromNullable(typeChecker.typeToTypeNode(
+                initializerType,
+                void 0,
+                ts.NodeBuilderFlags.NoTruncation
+              ))
+            ),
+            getOrUndefined
           );
           if (initializerTypeNode) {
             changeTracker.insertNodeAt(
@@ -1872,7 +1962,8 @@ var init = (modules) => {
   function create(info) {
     const languageService = info.languageService;
     const pluginOptions = {
-      diagnostics: info.config && "diagnostics" in info.config && typeof info.config.diagnostics === "boolean" ? info.config.diagnostics : true
+      diagnostics: info.config && "diagnostics" in info.config && typeof info.config.diagnostics === "boolean" ? info.config.diagnostics : true,
+      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)) {
@@ -2005,8 +2096,13 @@ var init = (modules) => {
     };
     proxy.getQuickInfoAtPosition = (fileName, position, ...args) => {
       const quickInfo = languageService.getQuickInfoAtPosition(fileName, position, ...args);
-      if (quickInfo) {
-        return dedupeJsDocTags(quickInfo);
+      if (pluginOptions.quickinfo && quickInfo) {
+        const dedupedTagsQuickInfo = dedupeJsDocTags(quickInfo);
+        const program = languageService.getProgram();
+        if (program) {
+          return prependEffectTypeArguments(ts, program)(fileName, position, dedupedTagsQuickInfo);
+        }
+        return dedupedTagsQuickInfo;
       }
       return quickInfo;
     };