@effect/language-service 0.10.2 → 0.11.0

package/README.md

@@ -71,6 +71,7 @@ Few options can be provided alongside the initialization of the Language Service
 - 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`
 
 ## Configuring diagnostics
 

package/index.js

@@ -1166,24 +1166,7 @@ var transformAsyncAwaitToEffectGen = fn("AST.transformAsyncAwaitToEffectGen")(
       return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
     }
     const generatorBody = visitor(node.body);
-    const generator = ts.factory.createFunctionExpression(
-      void 0,
-      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-      void 0,
-      [],
-      [],
-      void 0,
-      generatorBody
-      // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
-    );
-    const effectGenCallExp = ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createIdentifier(effectModuleName),
-        "gen"
-      ),
-      void 0,
-      [generator]
-    );
+    const effectGenCallExp = yield* createEffectGenCallExpression(effectModuleName, generatorBody);
     let currentFlags = ts.getCombinedModifierFlags(node);
     currentFlags &= ~ts.ModifierFlags.Async;
     const newModifiers = ts.factory.createModifiersFromModifierFlags(currentFlags);
@@ -1405,6 +1388,47 @@ var parseDataForExtendsClassCompletion = fn(
     { accessedObject, classDeclaration, className: classDeclaration.name, replacementSpan }
   );
 });
+var createEffectGenCallExpression = fn("AST.createEffectGenCallExpression")(function* (effectModuleIdentifierName, node) {
+  const ts = yield* service(TypeScriptApi);
+  const generator = ts.factory.createFunctionExpression(
+    void 0,
+    ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+    void 0,
+    [],
+    [],
+    void 0,
+    node
+    // NOTE(mattia): intended, to use same routine for both ConciseBody and Body
+  );
+  return ts.factory.createCallExpression(
+    ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier(effectModuleIdentifierName),
+      "gen"
+    ),
+    void 0,
+    [generator]
+  );
+});
+var createEffectGenCallExpressionWithBlock = fn(
+  "AST.createEffectGenCallExpressionWithBlock"
+)(function* (effectModuleIdentifierName, statement) {
+  const ts = yield* service(TypeScriptApi);
+  return yield* createEffectGenCallExpression(
+    effectModuleIdentifierName,
+    ts.factory.createBlock(Array.isArray(statement) ? statement : [statement], false)
+  );
+});
+var createReturnYieldStarStatement = fn("AST.createReturnYieldStarStatement")(
+  function* (expr) {
+    const ts = yield* service(TypeScriptApi);
+    return ts.factory.createReturnStatement(
+      ts.factory.createYieldExpression(
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        expr
+      )
+    );
+  }
+);
 
 // src/core/LSP.ts
 var RefactorNotApplicableError = class {
@@ -3103,6 +3127,65 @@ var toggleTypeAnnotation = createRefactor({
   })
 });
 
+// src/refactors/wrapWithEffectGen.ts
+var wrapWithEffectGen = createRefactor({
+  name: "effect/wrapWithEffectGen",
+  description: "Wrap with Effect.gen",
+  apply: (sourceFile, textRange) => gen2(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const findEffectToWrap = fn("findEffectToWrap")(function* (node2) {
+      if (!ts.isExpression(node2)) return yield* fail("is not an expression");
+      const parent = node2.parent;
+      if (parent != null && ts.isVariableDeclaration(parent) && parent.initializer !== node2) return yield* fail("is LHS of variable declaration");
+      const type = typeChecker.getTypeAtLocation(node2);
+      yield* effectType(type, node2);
+      return node2;
+    });
+    const maybeNode = yield* pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      map2(findEffectToWrap),
+      firstSuccessOf,
+      option
+    );
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    if (!ts.isExpression(node)) return yield* fail(new RefactorNotApplicableError());
+    const effectGen2 = yield* createEffectGenCallExpressionWithBlock(
+      yield* getEffectModuleIdentifierName(sourceFile),
+      yield* createReturnYieldStarStatement(node)
+    );
+    return {
+      kind: "refactor.rewrite.effect.wrapWithEffectGen",
+      description: `Wrap with Effect.gen`,
+      apply: gen2(function* () {
+        const changeTracker = yield* service(ChangeTracker);
+        changeTracker.replaceNode(sourceFile, node, effectGen2);
+      })
+    };
+  })
+});
+var getEffectModuleIdentifierName = fn("getEffectModuleIdentifierName")(
+  function* (sourceFile) {
+    return match2(
+      yield* option(
+        findImportedModuleIdentifier(
+          sourceFile,
+          (node) => pipe(
+            importedEffectModule(node),
+            option,
+            map3(isSome2)
+          )
+        )
+      ),
+      {
+        onNone: () => "Effect",
+        onSome: (node) => node.text
+      }
+    );
+  }
+);
+
 // src/refactors/wrapWithPipe.ts
 var wrapWithPipe = createRefactor({
   name: "effect/wrapWithPipe",
@@ -3133,6 +3216,7 @@ var refactors = [
   toggleLazyConst,
   toggleReturnTypeAnnotation,
   toggleTypeAnnotation,
+  wrapWithEffectGen,
   wrapWithPipe,
   effectGenToFn
 ];