@effect/language-service 0.34.0 → 0.35.0

package/index.js

@@ -135,9 +135,6 @@ var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
-// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/errors.js
-var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
-
 // node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var GenKindImpl = class {
@@ -238,12 +235,6 @@ var YieldWrap = class {
     return this.#value;
   }
 };
-function yieldWrapGet(self) {
-  if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
-    return self[YieldWrapTypeId]();
-  }
-  throw new Error(getBugErrorMessage("yieldWrapGet"));
-}
 var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
   enabled: false,
   tester: void 0
@@ -748,6 +739,31 @@ var NanoTag = class {
   }
 };
 var Tag = (identifier) => new NanoTag(identifier);
+var SingleShotGen2 = class _SingleShotGen {
+  called = false;
+  self;
+  constructor(self) {
+    this.self = self;
+  }
+  /**
+   * @since 2.0.0
+   */
+  next(a) {
+    return this.called ? {
+      value: a,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
+  /**
+   * @since 2.0.0
+   */
+  [Symbol.iterator]() {
+    return new _SingleShotGen(this.self);
+  }
+};
 var evaluate = Symbol.for("Nano.evaluate");
 var contA = Symbol.for("Nano.contA");
 var contE = Symbol.for("Nano.contE");
@@ -762,7 +778,7 @@ var NanoDefectException = class {
 };
 var PrimitiveProto = {
   [Symbol.iterator]() {
-    return new SingleShotGen(new YieldWrap(this));
+    return new SingleShotGen2(this);
   }
 };
 var SucceedProto = {
@@ -885,7 +901,7 @@ var FromIteratorProto = {
     const state = this[args][0].next(value);
     if (state.done) return succeed(state.value);
     fiber._stack.push(this);
-    return yieldWrapGet(state.value);
+    return state.value;
   },
   [evaluate](fiber) {
     return this[contA](this[args][1], fiber);
@@ -1256,7 +1272,7 @@ function makeTypeScriptUtils(ts) {
   function isNodeInRange(textRange) {
     return (node) => node.pos <= textRange.pos && node.end >= textRange.end;
   }
-  function transformAsyncAwaitToEffectGen(node, effectModuleName, onAwait) {
+  function transformAsyncAwaitToEffectGeneratorBody(body, onAwait) {
     function visitor(_) {
       if (ts.isAwaitExpression(_)) {
         const expression = ts.visitEachChild(_.expression, visitor, ts.nullTransformationContext);
@@ -1267,7 +1283,44 @@ function makeTypeScriptUtils(ts) {
       }
       return ts.visitEachChild(_, visitor, ts.nullTransformationContext);
     }
-    const generatorBody = visitor(node.body);
+    return visitor(body);
+  }
+  function transformAsyncAwaitToEffectFn(node, effectModuleName, onAwait) {
+    const generatorBody = transformAsyncAwaitToEffectGeneratorBody(node.body, onAwait);
+    const fnName = node.name && ts.isIdentifier(node.name) ? node.name : ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) && node.parent.initializer === node ? node.parent.name : void 0;
+    let fnCall = ts.factory.createPropertyAccessExpression(
+      ts.factory.createIdentifier(effectModuleName),
+      "fn"
+    );
+    if (fnName) {
+      fnCall = ts.factory.createCallExpression(
+        fnName,
+        void 0,
+        [ts.factory.createStringLiteral(fnName.text)]
+      );
+    }
+    return tryPreserveDeclarationSemantics(
+      node,
+      ts.factory.createCallExpression(
+        fnCall,
+        void 0,
+        [
+          ts.factory.createFunctionExpression(
+            void 0,
+            ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+            void 0,
+            node.typeParameters,
+            node.parameters,
+            void 0,
+            ts.isBlock(generatorBody) ? generatorBody : ts.factory.createBlock([ts.factory.createReturnStatement(generatorBody)])
+          )
+        ]
+      ),
+      true
+    );
+  }
+  function transformAsyncAwaitToEffectGen(node, effectModuleName, onAwait) {
+    const generatorBody = transformAsyncAwaitToEffectGeneratorBody(node.body, onAwait);
     const effectGenCallExp = createEffectGenCallExpression(effectModuleName, generatorBody);
     let currentFlags = ts.getCombinedModifierFlags(node);
     currentFlags &= ~ts.ModifierFlags.Async;
@@ -1371,12 +1424,15 @@ function makeTypeScriptUtils(ts) {
     }
     return typeNode;
   }
-  function tryPreserveDeclarationSemantics(nodeToReplace, node) {
+  function tryPreserveDeclarationSemantics(nodeToReplace, node, dropAsync) {
     if (!ts.isExpression(node)) return node;
     if (ts.isFunctionDeclaration(nodeToReplace)) {
       if (!nodeToReplace.name) return node;
+      let currentFlags = ts.getCombinedModifierFlags(nodeToReplace);
+      currentFlags &= ~ts.ModifierFlags.Async;
+      const newModifiers = dropAsync ? ts.factory.createModifiersFromModifierFlags(currentFlags) : nodeToReplace.modifiers;
       return ts.factory.createVariableStatement(
-        nodeToReplace.modifiers,
+        newModifiers,
         ts.factory.createVariableDeclarationList(
           [ts.factory.createVariableDeclaration(
             nodeToReplace.name,
@@ -1388,8 +1444,11 @@ function makeTypeScriptUtils(ts) {
         )
       );
     } else if (ts.isMethodDeclaration(nodeToReplace)) {
+      let currentFlags = ts.getCombinedModifierFlags(nodeToReplace);
+      currentFlags &= ~ts.ModifierFlags.Async;
+      const newModifiers = dropAsync ? ts.factory.createModifiersFromModifierFlags(currentFlags) : nodeToReplace.modifiers;
       return ts.factory.createPropertyDeclaration(
-        nodeToReplace.modifiers,
+        newModifiers,
         nodeToReplace.name,
         void 0,
         void 0,
@@ -1492,6 +1551,7 @@ function makeTypeScriptUtils(ts) {
     getAncestorNodesInRange,
     toTextRange,
     isNodeInRange,
+    transformAsyncAwaitToEffectFn,
     transformAsyncAwaitToEffectGen,
     findImportedModuleIdentifierByPackageAndNameOrBarrel,
     simplifyTypeNode,
@@ -10722,6 +10782,156 @@ function quickInfo(sourceFile, position, quickInfo2) {
   });
 }
 
+// src/refactors/asyncAwaitToFn.ts
+var asyncAwaitToFn = createRefactor({
+  name: "asyncAwaitToFn",
+  description: "Convert to Effect.fn",
+  apply: fn("asyncAwaitToFn.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeNode = pipe(
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      filter(
+        (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
+      ),
+      filter((node2) => !!node2.body),
+      filter((node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.asyncAwaitToFn",
+      description: "Rewrite to Effect.fn",
+      apply: pipe(
+        gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const effectModuleIdentifierName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+            sourceFile,
+            "effect",
+            "Effect"
+          ) || "Effect";
+          const newDeclaration = tsUtils.transformAsyncAwaitToEffectFn(
+            node,
+            effectModuleIdentifierName,
+            (expression) => ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectModuleIdentifierName),
+                "promise"
+              ),
+              void 0,
+              [
+                ts.factory.createArrowFunction(
+                  void 0,
+                  void 0,
+                  [],
+                  void 0,
+                  void 0,
+                  expression
+                )
+              ]
+            )
+          );
+          changeTracker.replaceNode(sourceFile, node, newDeclaration);
+        }),
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerApi, typeChecker)
+      )
+    };
+  })
+});
+
+// src/refactors/asyncAwaitToFnTryPromise.ts
+var asyncAwaitToFnTryPromise = createRefactor({
+  name: "asyncAwaitToFnTryPromise",
+  description: "Convert to Effect.fn with failures",
+  apply: fn("asyncAwaitToFnTryPromise.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeNode = pipe(
+      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
+      filter(
+        (node2) => ts.isFunctionDeclaration(node2) || ts.isArrowFunction(node2) || ts.isFunctionExpression(node2)
+      ),
+      filter((node2) => !!node2.body),
+      filter((node2) => !!(ts.getCombinedModifierFlags(node2) & ts.ModifierFlags.Async)),
+      head
+    );
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    const node = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.asyncAwaitToFnTryPromise",
+      description: "Rewrite to Effect.fn with failures",
+      apply: pipe(
+        gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const effectModuleIdentifierName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+            sourceFile,
+            "effect",
+            "Effect"
+          ) || "Effect";
+          let errorCount = 0;
+          function createErrorADT() {
+            errorCount++;
+            return ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment(
+                "_tag",
+                ts.factory.createAsExpression(
+                  ts.factory.createStringLiteral("Error" + errorCount),
+                  ts.factory.createTypeReferenceNode("const")
+                )
+              ),
+              ts.factory.createShorthandPropertyAssignment("error")
+            ]);
+          }
+          const newDeclaration = tsUtils.transformAsyncAwaitToEffectFn(
+            node,
+            effectModuleIdentifierName,
+            (expression) => ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectModuleIdentifierName),
+                "tryPromise"
+              ),
+              void 0,
+              [
+                ts.factory.createObjectLiteralExpression([
+                  ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("try"),
+                    ts.factory.createArrowFunction(
+                      void 0,
+                      void 0,
+                      [],
+                      void 0,
+                      void 0,
+                      expression
+                    )
+                  ),
+                  ts.factory.createPropertyAssignment(
+                    ts.factory.createIdentifier("catch"),
+                    ts.factory.createArrowFunction(
+                      void 0,
+                      void 0,
+                      [ts.factory.createParameterDeclaration(void 0, void 0, "error")],
+                      void 0,
+                      void 0,
+                      createErrorADT()
+                    )
+                  )
+                ])
+              ]
+            )
+          );
+          changeTracker.replaceNode(sourceFile, node, newDeclaration);
+        }),
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerApi, typeChecker)
+      )
+    };
+  })
+});
+
 // src/refactors/asyncAwaitToGen.ts
 var asyncAwaitToGen = createRefactor({
   name: "asyncAwaitToGen",
@@ -10902,6 +11112,7 @@ var effectGenToFn = createRefactor({
     const nodesFromInitializers = pipe(
       parentNodes,
       filter((_) => ts.isVariableDeclaration(_) && _.initializer ? true : false),
+      filter((_) => tsUtils.isNodeInRange(textRange)(_.name)),
       map4((_) => _.initializer)
     );
     const maybeNode = yield* pipe(
@@ -10945,7 +11156,7 @@ var effectGenToFn = createRefactor({
           changeTracker.replaceNode(
             sourceFile,
             nodeToReplace,
-            tsUtils.tryPreserveDeclarationSemantics(nodeToReplace, effectFnCallWithGenerator)
+            tsUtils.tryPreserveDeclarationSemantics(nodeToReplace, effectFnCallWithGenerator, false)
           );
         }),
         provideService(TypeScriptApi, ts)
@@ -10998,7 +11209,8 @@ var functionToArrow = createRefactor({
           );
           const newDeclaration = tsUtils.tryPreserveDeclarationSemantics(
             node,
-            arrowFunction
+            arrowFunction,
+            false
           );
           changeTracker.replaceNode(sourceFile, node, newDeclaration, {
             leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
@@ -12214,6 +12426,8 @@ var wrapWithPipe = createRefactor({
 var refactors = [
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
+  asyncAwaitToFn,
+  asyncAwaitToFnTryPromise,
   functionToArrow,
   typeToEffectSchema,
   typeToEffectSchemaClass,