@effect/language-service 0.33.2 → 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,
@@ -4475,6 +4535,68 @@ var outdatedEffectCodegen = createDiagnostic({
   })
 });
 
+// src/diagnostics/overriddenSchemaConstructor.ts
+var overriddenSchemaConstructor = createDiagnostic({
+  name: "overriddenSchemaConstructor",
+  code: 30,
+  severity: "error",
+  apply: fn("overriddenSchemaConstructor.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.heritageClauses) {
+        let extendsSchema = false;
+        for (const heritageClause of node.heritageClauses) {
+          if (heritageClause.token === ts.SyntaxKind.ExtendsKeyword) {
+            for (const type of heritageClause.types) {
+              const typeAtLocation = typeChecker.getTypeAtLocation(type.expression);
+              const isSchema = yield* pipe(
+                typeParser.effectSchemaType(typeAtLocation, type.expression),
+                map3(() => true),
+                orElse2(() => succeed(false))
+              );
+              if (isSchema) {
+                extendsSchema = true;
+                break;
+              }
+            }
+          }
+          if (extendsSchema) break;
+        }
+        if (extendsSchema) {
+          const members = node.members;
+          for (const member of members) {
+            if (ts.isConstructorDeclaration(member)) {
+              report({
+                location: member,
+                messageText: "Classes extending Schema must not override the constructor",
+                fixes: [{
+                  fixName: "overriddenSchemaConstructor_fix",
+                  description: "Remove the constructor override",
+                  apply: gen(function* () {
+                    const changeTracker = yield* service(ChangeTracker);
+                    changeTracker.delete(sourceFile, member);
+                  })
+                }]
+              });
+              break;
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -4993,6 +5115,7 @@ var diagnostics = [
   strictBooleanExpressions,
   multipleEffectProvide,
   outdatedEffectCodegen,
+  overriddenSchemaConstructor,
   unsupportedServiceAccessors
 ];
 
@@ -10659,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",
@@ -10817,61 +11090,52 @@ var effectGenToFn = createRefactor({
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeParser = yield* service(TypeParser);
-    const parseEffectGenNode = fn("asyncAwaitToGen.apply")(function* (node) {
-      const effectGen = yield* typeParser.effectGen(node);
-      let pipeArgs2 = ts.factory.createNodeArray([]);
-      let nodeToReplace2 = node;
-      while (nodeToReplace2.parent) {
-        const parent = nodeToReplace2.parent;
-        if (ts.isConciseBody(nodeToReplace2) && ts.isArrowFunction(parent) && parent.body === nodeToReplace2) {
-          return { ...effectGen, pipeArgs: pipeArgs2, nodeToReplace: parent };
-        }
-        if ((ts.isFunctionDeclaration(parent) || ts.isMethodDeclaration(parent)) && parent.body === nodeToReplace2) {
-          return { ...effectGen, pipeArgs: pipeArgs2, nodeToReplace: parent };
-        }
-        if (ts.isBlock(parent) && parent.statements.length === 1 && parent.statements[0] === nodeToReplace2) {
-          nodeToReplace2 = parent;
-          continue;
-        }
-        if (ts.isReturnStatement(parent) && parent.expression === nodeToReplace2) {
-          nodeToReplace2 = parent;
-          continue;
-        }
-        const maybePipe = yield* pipe(
-          typeParser.pipeCall(parent),
-          orElse2((e) => parent.parent ? typeParser.pipeCall(parent.parent) : fail(e)),
-          option
-        );
-        if (isSome2(maybePipe) && maybePipe.value.subject === nodeToReplace2) {
-          pipeArgs2 = ts.factory.createNodeArray(pipeArgs2.concat(maybePipe.value.args));
-          nodeToReplace2 = maybePipe.value.node;
-          continue;
+    const skipReturnBlock = (node) => ts.isBlock(node) && node.statements.length === 1 && ts.isReturnStatement(node.statements[0]) && node.statements[0].expression ? node.statements[0].expression : node;
+    const parseFunctionLikeReturnEffectGen = fn("parseFunctionLikeReturnEffect.apply")(function* (node) {
+      if ((ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isFunctionDeclaration(node)) && node.body) {
+        let subject = skipReturnBlock(node.body);
+        let pipeArgs2 = [];
+        while (true) {
+          const maybePipe = yield* option(typeParser.pipeCall(subject));
+          if (isNone2(maybePipe)) break;
+          subject = maybePipe.value.subject;
+          pipeArgs2 = maybePipe.value.args.concat(pipeArgs2);
         }
-        break;
+        const fnIdentifier2 = node.name && ts.isIdentifier(node.name) ? node.name : ts.isVariableDeclaration(node.parent) && node.parent.name && ts.isIdentifier(node.parent.name) ? node.parent.name : void 0;
+        const effectGen = yield* typeParser.effectGen(subject);
+        return { ...effectGen, nodeToReplace: node, pipeArgs: pipeArgs2, fnIdentifier: fnIdentifier2 };
       }
       return yield* fail(new RefactorNotApplicableError());
     });
+    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
+    if (parentNodes.length === 0) return yield* fail(new RefactorNotApplicableError());
+    const nodesFromInitializers = pipe(
+      parentNodes,
+      filter((_) => ts.isVariableDeclaration(_) && _.initializer ? true : false),
+      filter((_) => tsUtils.isNodeInRange(textRange)(_.name)),
+      map4((_) => _.initializer)
+    );
     const maybeNode = yield* pipe(
-      tsUtils.getAncestorNodesInRange(sourceFile, textRange),
-      map4(parseEffectGenNode),
+      nodesFromInitializers.concat(parentNodes),
+      map4(parseFunctionLikeReturnEffectGen),
       firstSuccessOf,
       option
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
-    const { effectModule, generatorFunction, nodeToReplace, pipeArgs } = maybeNode.value;
+    const { effectModule, fnIdentifier, generatorFunction, nodeToReplace, pipeArgs } = maybeNode.value;
     return {
       kind: "refactor.rewrite.effect.effectGenToFn",
-      description: "Convert to Effect.fn",
+      description: fnIdentifier ? `Convert to Effect.fn("${fnIdentifier.text}")` : "Convert to Effect.fn",
       apply: pipe(
         gen(function* () {
           const changeTracker = yield* service(ChangeTracker);
-          const effectFn = nodeToReplace.name && ts.isIdentifier(nodeToReplace.name) ? ts.factory.createCallExpression(
+          const effectFn = fnIdentifier ? ts.factory.createCallExpression(
             ts.factory.createPropertyAccessExpression(
               effectModule,
               "fn"
             ),
             void 0,
-            [ts.factory.createStringLiteral(nodeToReplace.name.text)]
+            [ts.factory.createStringLiteral(fnIdentifier.text)]
           ) : ts.factory.createPropertyAccessExpression(
             effectModule,
             "fn"
@@ -10892,7 +11156,7 @@ var effectGenToFn = createRefactor({
           changeTracker.replaceNode(
             sourceFile,
             nodeToReplace,
-            tsUtils.tryPreserveDeclarationSemantics(nodeToReplace, effectFnCallWithGenerator)
+            tsUtils.tryPreserveDeclarationSemantics(nodeToReplace, effectFnCallWithGenerator, false)
           );
         }),
         provideService(TypeScriptApi, ts)
@@ -10945,7 +11209,8 @@ var functionToArrow = createRefactor({
           );
           const newDeclaration = tsUtils.tryPreserveDeclarationSemantics(
             node,
-            arrowFunction
+            arrowFunction,
+            false
           );
           changeTracker.replaceNode(sourceFile, node, newDeclaration, {
             leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll,
@@ -12161,6 +12426,8 @@ var wrapWithPipe = createRefactor({
 var refactors = [
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
+  asyncAwaitToFn,
+  asyncAwaitToFnTryPromise,
   functionToArrow,
   typeToEffectSchema,
   typeToEffectSchemaClass,