@effect/language-service 0.25.0 → 0.26.0

package/index.js

@@ -903,6 +903,7 @@ var NanoFiber = class {
   _stack = [];
   _yielded = void 0;
   _services = {};
+  _cache = {};
   runLoop(nano) {
     let current = nano;
     while (true) {
@@ -1053,8 +1054,32 @@ var service = (tag) => {
   nano[args] = tag;
   return nano;
 };
-function cachedBy(fa, _key, _lookupKey) {
-  return (...args2) => fa(...args2);
+var CachedProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const [fa, type, key] = this[args];
+    const cache = fiber._cache[type] || /* @__PURE__ */ new WeakMap();
+    fiber._cache[type] = cache;
+    const cached2 = cache.get(key);
+    if (cached2) return cached2;
+    return match2(fa, {
+      onSuccess: (_) => {
+        cache.set(key, succeed(_));
+        return succeed(_);
+      },
+      onFailure: (_) => {
+        cache.set(key, fail(_));
+        return fail(_);
+      }
+    });
+  }
+};
+function cachedBy(fa, type, lookupKey) {
+  return (...p) => {
+    const nano = Object.create(CachedProto);
+    nano[args] = [fa(...p), type, lookupKey(...p)];
+    return nano;
+  };
 }
 var option = (fa) => {
   const nano = Object.create(MatchProto);
@@ -2018,8 +2043,7 @@ var unrollUnionMembers = (type) => {
 var appendToUniqueTypesMap = fn(
   "TypeCheckerApi.appendToUniqueTypesMap"
 )(
-  function* (memory, initialType, excludeNever) {
-    const ts = yield* service(TypeScriptApi);
+  function* (memory, initialType, shouldExclude) {
     const typeChecker = yield* service(TypeCheckerApi);
     const newIndexes = /* @__PURE__ */ new Set();
     const knownIndexes = /* @__PURE__ */ new Set();
@@ -2027,7 +2051,7 @@ var appendToUniqueTypesMap = fn(
     while (toTest.length > 0) {
       const type = toTest.pop();
       if (!type) break;
-      if (excludeNever && type.flags & ts.TypeFlags.Never) {
+      if (yield* shouldExclude(type)) {
         continue;
       }
       if (type.isUnion()) {
@@ -2650,11 +2674,16 @@ function make3(ts, typeChecker) {
   const pipeCall = cachedBy(
     function(node) {
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "pipe") {
-        return succeed({ node, subject: node.expression.expression, args: Array.from(node.arguments) });
+        return succeed({
+          node,
+          subject: node.expression.expression,
+          args: Array.from(node.arguments),
+          kind: "pipeable"
+        });
       }
       if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
         const [subject, ...args2] = node.arguments;
-        return succeed({ node, subject, args: args2 });
+        return succeed({ node, subject, args: args2, kind: "pipe" });
       }
       return typeParserIssue("Node is not a pipe call", void 0, node);
     },
@@ -2693,6 +2722,7 @@ function make3(ts, typeChecker) {
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
+    pipeableType,
     pipeCall,
     scopeType
   };
@@ -3014,7 +3044,18 @@ var leakingRequirements = createDiagnostic({
             );
             if (effectContextType) {
               effectMembers++;
-              const { allIndexes } = yield* appendToUniqueTypesMap(memory, effectContextType, true);
+              const { allIndexes } = yield* appendToUniqueTypesMap(
+                memory,
+                effectContextType,
+                (type) => {
+                  if (type.flags & ts.TypeFlags.Never) return succeed(true);
+                  return pipe(
+                    typeParser.scopeType(type, atLocation),
+                    map4(() => true),
+                    orElse2(() => succeed(false))
+                  );
+                }
+              );
               if (!sharedRequirementsKeys) {
                 sharedRequirementsKeys = allIndexes;
               } else {
@@ -3570,8 +3611,8 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
 // src/diagnostics/tryCatchInEffectGen.ts
 var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
-  code: 12,
-  severity: "warning",
+  code: 15,
+  severity: "suggestion",
   apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -3700,6 +3741,80 @@ var unnecessaryPipe = createDiagnostic({
   })
 });
 
+// src/diagnostics/unnecessaryPipeChain.ts
+var unnecessaryPipeChain = createDiagnostic({
+  name: "unnecessaryPipeChain",
+  code: 16,
+  severity: "suggestion",
+  apply: fn("unnecessaryPipeChain.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        yield* pipe(
+          typeParser.pipeCall(node),
+          flatMap2(
+            (pipeCall) => map4(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
+          ),
+          map4(({ innerCall, pipeCall }) => {
+            report({
+              node,
+              messageText: `Chained pipe calls can be simplified to a single pipe call`,
+              fixes: [{
+                fixName: "unnecessaryPipeChain_fix",
+                description: "Rewrite as single pipe call",
+                apply: gen(function* () {
+                  const changeTracker = yield* service(
+                    ChangeTracker
+                  );
+                  switch (innerCall.kind) {
+                    case "pipe": {
+                      changeTracker.replaceNode(
+                        sourceFile,
+                        node,
+                        ts.factory.createCallExpression(
+                          ts.factory.createIdentifier("pipe"),
+                          void 0,
+                          [innerCall.subject, ...innerCall.args, ...pipeCall.args]
+                        )
+                      );
+                      break;
+                    }
+                    case "pipeable": {
+                      changeTracker.replaceNode(
+                        sourceFile,
+                        node,
+                        ts.factory.createCallExpression(
+                          ts.factory.createPropertyAccessExpression(
+                            innerCall.subject,
+                            "pipe"
+                          ),
+                          void 0,
+                          [...innerCall.args, ...pipeCall.args]
+                        )
+                      );
+                      break;
+                    }
+                  }
+                })
+              }]
+            });
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics.ts
 var diagnostics = [
   duplicatePackage,
@@ -3716,7 +3831,8 @@ var diagnostics = [
   tryCatchInEffectGen,
   importFromBarrel,
   scopeInLayerEffect,
-  effectInVoidSuccess
+  effectInVoidSuccess,
+  unnecessaryPipeChain
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -8796,6 +8912,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
+    const excludeNever = (type) => succeed((type.flags & ts.TypeFlags.Never) !== 0);
     const maybePipe = yield* option(typeParser.pipeCall(node));
     if (isSome2(maybePipe)) {
       let graphNode = yield* processLayerGraphNode(ctx, maybePipe.value.subject, void 0);
@@ -8815,12 +8932,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
           const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
             ctx.services,
             maybeLayer.value.ROut,
-            true
+            excludeNever
           );
           const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
             ctx.services,
             maybeLayer.value.RIn,
-            true
+            excludeNever
           );
           return new GraphNodeCompoundTransform(
             ctx.nextId(),
@@ -8844,12 +8961,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
             const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
               ctx.services,
               maybeLayer.value.ROut,
-              true
+              excludeNever
             );
             const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
               ctx.services,
               maybeLayer.value.RIn,
-              true
+              excludeNever
             );
             if (ts.isCallExpression(node)) {
               const argNodes = yield* option(
@@ -8894,12 +9011,12 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
         const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
           ctx.services,
           maybeLayer.value.ROut,
-          true
+          excludeNever
         );
         const { allIndexes: inTypes } = yield* appendToUniqueTypesMap(
           ctx.services,
           maybeLayer.value.RIn,
-          true
+          excludeNever
         );
         return new GraphNodeLeaf(ctx.nextId(), node, outTypes, inTypes);
       }
@@ -9892,6 +10009,66 @@ var toggleLazyConst = createRefactor({
   })
 });
 
+// src/refactors/togglePipeStyle.ts
+var togglePipeStyle = createRefactor({
+  name: "togglePipeStyle",
+  description: "Toggle pipe style",
+  apply: fn("togglePipeStyle.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const togglePipeStyle2 = (node) => gen(function* () {
+      const pipeCall = yield* typeParser.pipeCall(node);
+      switch (pipeCall.kind) {
+        case "pipe": {
+          yield* typeParser.pipeableType(typeChecker.getTypeAtLocation(pipeCall.subject), pipeCall.subject);
+          return {
+            kind: "refactor.rewrite.effect.togglePipeStyle",
+            description: "Rewrite as X.pipe(Y, Z, ...)",
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              changeTracker.replaceNode(
+                sourceFile,
+                node,
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    pipeCall.subject,
+                    "pipe"
+                  ),
+                  void 0,
+                  pipeCall.args
+                )
+              );
+            })
+          };
+        }
+        case "pipeable":
+          return {
+            kind: "refactor.rewrite.effect.togglePipeStyle",
+            description: "Rewrite as pipe(X, Y, Z, ...)",
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              changeTracker.replaceNode(
+                sourceFile,
+                node,
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("pipe"),
+                  void 0,
+                  [pipeCall.subject].concat(pipeCall.args)
+                )
+              );
+            })
+          };
+      }
+    });
+    const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, textRange);
+    return yield* pipe(
+      firstSuccessOf(ancestorNodes.map(togglePipeStyle2)),
+      orElse2(() => fail(new RefactorNotApplicableError()))
+    );
+  })
+});
+
 // src/refactors/toggleReturnTypeAnnotation.ts
 var toggleReturnTypeAnnotation = createRefactor({
   name: "toggleReturnTypeAnnotation",
@@ -10608,7 +10785,8 @@ var refactors = [
   toggleTypeAnnotation,
   wrapWithEffectGen,
   wrapWithPipe,
-  effectGenToFn
+  effectGenToFn,
+  togglePipeStyle
 ];
 
 // src/index.ts