@effect/language-service 0.33.1 → 0.34.0

package/index.js

@@ -4475,6 +4475,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 +5055,7 @@ var diagnostics = [
   strictBooleanExpressions,
   multipleEffectProvide,
   outdatedEffectCodegen,
+  overriddenSchemaConstructor,
   unsupportedServiceAccessors
 ];
 
@@ -10817,61 +10880,51 @@ 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 };
+    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);
         }
-        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;
-        }
-        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),
+      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"