@effect/language-service 0.10.2 → 0.12.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 {
@@ -1945,6 +1969,13 @@ function covariantTypeArgument(type) {
   }
   return succeed(signatures[0].getReturnType());
 }
+function invariantTypeArgument(type) {
+  const signatures = type.getCallSignatures();
+  if (signatures.length !== 1) {
+    return typeParserIssue("Invariant type has no call signature", type);
+  }
+  return succeed(signatures[0].getReturnType());
+}
 var pipeableType = fn("TypeParser.pipeableType")(function* (type, atLocation) {
   const typeChecker = yield* service(TypeCheckerApi);
   const pipeSymbol = typeChecker.getPropertyOfType(type, "pipe");
@@ -1969,6 +2000,17 @@ var varianceStructCovariantType = fn("TypeParser.varianceStructCovariantType")(
     return yield* covariantTypeArgument(propertyType);
   }
 );
+var varianceStructInvariantType = fn("TypeParser.varianceStructInvariantType")(
+  function* (type, atLocation, propertyName) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const propertySymbol = typeChecker.getPropertyOfType(type, propertyName);
+    if (!propertySymbol) {
+      return yield* typeParserIssue(`Type has no '${propertyName}' property`, type, atLocation);
+    }
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    return yield* invariantTypeArgument(propertyType);
+  }
+);
 var effectVarianceStruct = fn("TypeParser.effectVarianceStruct")(function* (type, atLocation) {
   return {
     A: yield* varianceStructCovariantType(type, atLocation, "_A"),
@@ -2175,6 +2217,37 @@ var returnYieldEffectBlock = fn("TypeParser.returnYieldEffectBlock")(function* (
     body
   );
 });
+var effectSchemaVarianceStruct = fn("TypeParser.effectSchemaVarianceStruct")(
+  function* (type, atLocation) {
+    return {
+      A: yield* varianceStructInvariantType(type, atLocation, "_A"),
+      I: yield* varianceStructInvariantType(type, atLocation, "_I"),
+      R: yield* varianceStructCovariantType(type, atLocation, "_R")
+    };
+  }
+);
+var effectSchemaType = fn("TypeParser.effectSchemaType")(function* (type, atLocation) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  yield* pipeableType(type, atLocation);
+  const ast = typeChecker.getPropertyOfType(type, "ast");
+  if (!ast) return yield* typeParserIssue("Has no 'ast' property", type, atLocation);
+  const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
+    (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional)
+  );
+  propertiesSymbols.sort((a, b) => b.name.indexOf("TypeId") - a.name.indexOf("TypeId"));
+  for (const propertySymbol of propertiesSymbols) {
+    const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
+    const varianceArgs = yield* option(effectSchemaVarianceStruct(
+      propertyType,
+      atLocation
+    ));
+    if (isSome2(varianceArgs)) {
+      return varianceArgs.value;
+    }
+  }
+  return yield* typeParserIssue("Type has no schema variance struct", type, atLocation);
+});
 
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
@@ -2535,7 +2608,7 @@ function prependEffectTypeArguments(sourceFile, position, quickInfo) {
 var asyncAwaitToGen = createRefactor({
   name: "effect/asyncAwaitToGen",
   description: "Convert to Effect.gen",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("asyncAwaitToGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = pipe(
@@ -2607,7 +2680,7 @@ var asyncAwaitToGen = createRefactor({
 var asyncAwaitToGenTryPromise = createRefactor({
   name: "effect/asyncAwaitToGenTryPromise",
   description: "Convert to Effect.gen with failures",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("asyncAwaitToGenTryPromise.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = pipe(
@@ -2709,34 +2782,32 @@ var asyncAwaitToGenTryPromise = createRefactor({
 var effectGenToFn = createRefactor({
   name: "effect/effectGenToFn",
   description: "Convert to Effect.fn",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("effectGenToFn.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
-    function parseEffectGenNode(node) {
-      return gen2(function* () {
-        const effectGen2 = yield* effectGen(node);
-        let pipeArgs2 = ts.factory.createNodeArray([]);
-        let nodeToReplace2 = node.parent;
-        if (ts.isPropertyAccessExpression(node.parent) && node.parent.name.text === "pipe" && ts.isCallExpression(node.parent.parent)) {
-          pipeArgs2 = node.parent.parent.arguments;
-          nodeToReplace2 = node.parent.parent.parent;
+    const parseEffectGenNode = fn("asyncAwaitToGen.apply")(function* (node) {
+      const effectGen2 = yield* effectGen(node);
+      let pipeArgs2 = ts.factory.createNodeArray([]);
+      let nodeToReplace2 = node.parent;
+      if (ts.isPropertyAccessExpression(node.parent) && node.parent.name.text === "pipe" && ts.isCallExpression(node.parent.parent)) {
+        pipeArgs2 = node.parent.parent.arguments;
+        nodeToReplace2 = node.parent.parent.parent;
+      }
+      while (nodeToReplace2) {
+        if (ts.isArrowFunction(nodeToReplace2) || ts.isFunctionDeclaration(nodeToReplace2) || ts.isMethodDeclaration(nodeToReplace2)) {
+          return { ...effectGen2, pipeArgs: pipeArgs2, nodeToReplace: nodeToReplace2 };
         }
-        while (nodeToReplace2) {
-          if (ts.isArrowFunction(nodeToReplace2) || ts.isFunctionDeclaration(nodeToReplace2) || ts.isMethodDeclaration(nodeToReplace2)) {
-            return { ...effectGen2, pipeArgs: pipeArgs2, nodeToReplace: nodeToReplace2 };
-          }
-          if (ts.isConciseBody(nodeToReplace2) || ts.isReturnStatement(nodeToReplace2)) {
-            nodeToReplace2 = nodeToReplace2.parent;
-            continue;
-          }
-          if (ts.isBlock(nodeToReplace2) && nodeToReplace2.statements.length === 1) {
-            nodeToReplace2 = nodeToReplace2.parent;
-            continue;
-          }
-          break;
+        if (ts.isConciseBody(nodeToReplace2) || ts.isReturnStatement(nodeToReplace2)) {
+          nodeToReplace2 = nodeToReplace2.parent;
+          continue;
         }
-        return yield* fail(new RefactorNotApplicableError());
-      });
-    }
+        if (ts.isBlock(nodeToReplace2) && nodeToReplace2.statements.length === 1) {
+          nodeToReplace2 = nodeToReplace2.parent;
+          continue;
+        }
+        break;
+      }
+      return yield* fail(new RefactorNotApplicableError());
+    });
     const maybeNode = yield* pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
       map2(parseEffectGenNode),
@@ -2791,7 +2862,7 @@ var effectGenToFn = createRefactor({
 var functionToArrow = createRefactor({
   name: "effect/functionToArrow",
   description: "Convert to arrow",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("functionToArrow.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const maybeNode = pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
@@ -2843,11 +2914,180 @@ var functionToArrow = createRefactor({
   })
 });
 
+// src/refactors/makeSchemaOpaque.ts
+var makeSchemaOpaque = createRefactor({
+  name: "effect/makeSchemaOpaque",
+  description: "Make Schema opaque",
+  apply: fn("makeSchemaOpaque.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const findSchema = fn("makeSchemaOpaque.apply.findSchema")(
+      function* (node) {
+        if (!ts.isVariableDeclaration(node)) {
+          return yield* fail("parent should be variable declaration");
+        }
+        const identifier2 = node.name;
+        if (!ts.isIdentifier(identifier2)) return yield* fail("name should be an identifier");
+        const initializer = node.initializer;
+        if (!initializer) return yield* fail("should have an initializer");
+        const variableDeclarationList2 = node.parent;
+        if (!variableDeclarationList2 || !ts.isVariableDeclarationList(variableDeclarationList2)) {
+          return yield* fail("parent is not a variable declaration list");
+        }
+        const variableStatement2 = variableDeclarationList2.parent;
+        if (!variableStatement2 || !ts.isVariableStatement(variableStatement2)) {
+          return yield* fail("parent not variable declaration statement");
+        }
+        const type = typeChecker.getTypeAtLocation(initializer);
+        const types2 = yield* effectSchemaType(type, initializer);
+        return { identifier: identifier2, variableStatement: variableStatement2, variableDeclarationList: variableDeclarationList2, types: types2 };
+      }
+    );
+    const maybeNode = yield* pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      map2(findSchema),
+      firstSuccessOf,
+      option
+    );
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    const { identifier, types, variableDeclarationList, variableStatement } = maybeNode.value;
+    return {
+      kind: "refactor.rewrite.effect.makeSchemaOpaque",
+      description: `Make Schema opaque`,
+      apply: pipe(
+        gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const effectSchemaName = match2(
+            yield* option(
+              findImportedModuleIdentifierByPackageAndNameOrBarrel(
+                sourceFile,
+                "effect",
+                "Schema"
+              )
+            ),
+            {
+              onNone: () => "Schema",
+              onSome: (_) => _.text
+            }
+          );
+          const newIdentifier = ts.factory.createIdentifier(identifier.text + "_");
+          const opaqueInferred = ts.factory.createExpressionWithTypeArguments(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectSchemaName),
+                ts.factory.createIdentifier("Schema")
+              ),
+              ts.factory.createIdentifier("Type")
+            ),
+            [ts.factory.createTypeQueryNode(
+              ts.factory.createIdentifier(newIdentifier.text)
+            )]
+          );
+          const opaqueType = types.A.isUnion() ? ts.factory.createTypeAliasDeclaration(
+            variableStatement.modifiers,
+            identifier.text,
+            [],
+            opaqueInferred
+          ) : ts.factory.createInterfaceDeclaration(
+            variableStatement.modifiers,
+            identifier.text,
+            void 0,
+            [ts.factory.createHeritageClause(
+              ts.SyntaxKind.ExtendsKeyword,
+              [opaqueInferred]
+            )],
+            []
+          );
+          const encodedInferred = ts.factory.createExpressionWithTypeArguments(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectSchemaName),
+                ts.factory.createIdentifier("Schema")
+              ),
+              ts.factory.createIdentifier("Encoded")
+            ),
+            [ts.factory.createTypeQueryNode(
+              ts.factory.createIdentifier(newIdentifier.text)
+            )]
+          );
+          const encodedType = types.I.isUnion() ? ts.factory.createTypeAliasDeclaration(
+            variableStatement.modifiers,
+            identifier.text + "Encoded",
+            [],
+            encodedInferred
+          ) : ts.factory.createInterfaceDeclaration(
+            variableStatement.modifiers,
+            identifier.text + "Encoded",
+            void 0,
+            [ts.factory.createHeritageClause(
+              ts.SyntaxKind.ExtendsKeyword,
+              [encodedInferred]
+            )],
+            []
+          );
+          const contextInferred = ts.factory.createExpressionWithTypeArguments(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(effectSchemaName),
+                ts.factory.createIdentifier("Schema")
+              ),
+              ts.factory.createIdentifier("Context")
+            ),
+            [ts.factory.createTypeQueryNode(
+              ts.factory.createIdentifier(newIdentifier.text)
+            )]
+          );
+          const contextType = ts.factory.createTypeAliasDeclaration(
+            variableStatement.modifiers,
+            identifier.text + "Context",
+            [],
+            contextInferred
+          );
+          changeTracker.replaceNode(
+            sourceFile,
+            identifier,
+            newIdentifier
+          );
+          changeTracker.insertNodeAfter(sourceFile, variableStatement, opaqueType);
+          changeTracker.insertNodeAfter(sourceFile, variableStatement, encodedType);
+          changeTracker.insertNodeAfter(sourceFile, variableStatement, contextType);
+          const newSchemaType = ts.factory.createTypeReferenceNode(
+            ts.factory.createQualifiedName(
+              ts.factory.createIdentifier(effectSchemaName),
+              ts.factory.createIdentifier("Schema")
+            ),
+            [
+              ts.factory.createTypeReferenceNode(opaqueType.name),
+              ts.factory.createTypeReferenceNode(encodedType.name),
+              ts.factory.createTypeReferenceNode(contextType.name)
+            ]
+          );
+          const newConstDeclaration = ts.factory.createVariableStatement(
+            variableStatement.modifiers,
+            ts.factory.createVariableDeclarationList(
+              [ts.factory.createVariableDeclaration(
+                identifier.text,
+                void 0,
+                newSchemaType,
+                ts.factory.createIdentifier(newIdentifier.text)
+              )],
+              variableDeclarationList.flags
+            )
+          );
+          changeTracker.insertNodeAfter(sourceFile, variableStatement, newConstDeclaration);
+          changeTracker.insertText(sourceFile, variableStatement.end, "\n");
+        }),
+        provideService(TypeScriptApi, ts)
+      )
+    };
+  })
+});
+
 // src/refactors/pipeableToDatafirst.ts
 var pipeableToDatafirst = createRefactor({
   name: "effect/pipeableToDatafirst",
   description: "Rewrite to datafirst",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("pipeableToDatafirst.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     function isPipeCall(node2) {
@@ -2930,7 +3170,7 @@ var pipeableToDatafirst = createRefactor({
 var removeUnnecessaryEffectGen = createRefactor({
   name: "effect/removeUnnecessaryEffectGen",
   description: "Remove unnecessary Effect.gen",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("removeUnnecessaryEffectGen.apply")(function* (sourceFile, textRange) {
     for (const nodeToReplace of yield* getAncestorNodesInRange(sourceFile, textRange)) {
       const maybeNode = yield* pipe(
         effectGen(nodeToReplace),
@@ -2956,7 +3196,7 @@ var removeUnnecessaryEffectGen = createRefactor({
 var toggleLazyConst = createRefactor({
   name: "effect/toggleLazyConst",
   description: "Toggle lazy const",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("toggleLazyConst.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const maybeNode = pipe(
       yield* getAncestorNodesInRange(sourceFile, textRange),
@@ -2996,7 +3236,7 @@ var toggleLazyConst = createRefactor({
 var toggleReturnTypeAnnotation = createRefactor({
   name: "effect/toggleReturnTypeAnnotation",
   description: "Toggle return type annotation",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("toggleReturnTypeAnnotation.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = pipe(
@@ -3046,7 +3286,7 @@ var toggleReturnTypeAnnotation = createRefactor({
 var toggleTypeAnnotation = createRefactor({
   name: "effect/toggleTypeAnnotation",
   description: "Toggle type annotation",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("toggleTypeAnnotation.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = pipe(
@@ -3103,11 +3343,76 @@ var toggleTypeAnnotation = createRefactor({
   })
 });
 
+// src/refactors/wrapWithEffectGen.ts
+var wrapWithEffectGen = createRefactor({
+  name: "effect/wrapWithEffectGen",
+  description: "Wrap with Effect.gen",
+  apply: fn("wrapWithEffectGen.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const findEffectToWrap = fn("wrapWithEffectGen.apply.findEffectToWrap")(
+      function* (node) {
+        if (!ts.isExpression(node)) return yield* fail("is not an expression");
+        const parent = node.parent;
+        if (parent != null && ts.isVariableDeclaration(parent) && parent.initializer !== node) return yield* fail("is LHS of variable declaration");
+        const type = typeChecker.getTypeAtLocation(node);
+        yield* effectType(type, node);
+        return node;
+      }
+    );
+    const maybeNode = yield* pipe(
+      yield* getAncestorNodesInRange(sourceFile, textRange),
+      map2(findEffectToWrap),
+      firstSuccessOf,
+      option
+    );
+    if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
+    return {
+      kind: "refactor.rewrite.effect.wrapWithEffectGen",
+      description: `Wrap with Effect.gen`,
+      apply: pipe(
+        gen2(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const effectGen2 = yield* pipe(
+            createEffectGenCallExpressionWithBlock(
+              yield* getEffectModuleIdentifierName(sourceFile),
+              yield* createReturnYieldStarStatement(maybeNode.value)
+            )
+          );
+          changeTracker.replaceNode(sourceFile, maybeNode.value, effectGen2);
+        }),
+        provideService(TypeScriptApi, ts),
+        provideService(TypeCheckerApi, typeChecker)
+      )
+    };
+  })
+});
+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",
   description: "Wrap with pipe",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("wrapWithPipe.apply")(function* (sourceFile, textRange) {
     if (textRange.end - textRange.pos === 0) {
       return yield* fail(new RefactorNotApplicableError());
     }
@@ -3128,11 +3433,13 @@ var refactors = [
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
   functionToArrow,
+  makeSchemaOpaque,
   pipeableToDatafirst,
   removeUnnecessaryEffectGen,
   toggleLazyConst,
   toggleReturnTypeAnnotation,
   toggleTypeAnnotation,
+  wrapWithEffectGen,
   wrapWithPipe,
   effectGenToFn
 ];