@effect/language-service 0.11.0 → 0.12.0

package/index.js

@@ -1969,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");
@@ -1993,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"),
@@ -2199,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({
@@ -2559,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(
@@ -2631,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(
@@ -2733,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),
@@ -2815,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),
@@ -2867,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) {
@@ -2954,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),
@@ -2980,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),
@@ -3020,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(
@@ -3070,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(
@@ -3131,17 +3347,19 @@ var toggleTypeAnnotation = createRefactor({
 var wrapWithEffectGen = createRefactor({
   name: "effect/wrapWithEffectGen",
   description: "Wrap with Effect.gen",
-  apply: (sourceFile, textRange) => gen2(function* () {
+  apply: fn("wrapWithEffectGen.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
-    const findEffectToWrap = fn("findEffectToWrap")(function* (node2) {
-      if (!ts.isExpression(node2)) return yield* fail("is not an expression");
-      const parent = node2.parent;
-      if (parent != null && ts.isVariableDeclaration(parent) && parent.initializer !== node2) return yield* fail("is LHS of variable declaration");
-      const type = typeChecker.getTypeAtLocation(node2);
-      yield* effectType(type, node2);
-      return node2;
-    });
+    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),
@@ -3149,19 +3367,23 @@ var wrapWithEffectGen = createRefactor({
       option
     );
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
-    const node = maybeNode.value;
-    if (!ts.isExpression(node)) return yield* fail(new RefactorNotApplicableError());
-    const effectGen2 = yield* createEffectGenCallExpressionWithBlock(
-      yield* getEffectModuleIdentifierName(sourceFile),
-      yield* createReturnYieldStarStatement(node)
-    );
     return {
       kind: "refactor.rewrite.effect.wrapWithEffectGen",
       description: `Wrap with Effect.gen`,
-      apply: gen2(function* () {
-        const changeTracker = yield* service(ChangeTracker);
-        changeTracker.replaceNode(sourceFile, node, effectGen2);
-      })
+      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)
+      )
     };
   })
 });
@@ -3190,7 +3412,7 @@ var getEffectModuleIdentifierName = fn("getEffectModuleIdentifierName")(
 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());
     }
@@ -3211,6 +3433,7 @@ var refactors = [
   asyncAwaitToGen,
   asyncAwaitToGenTryPromise,
   functionToArrow,
+  makeSchemaOpaque,
   pipeableToDatafirst,
   removeUnnecessaryEffectGen,
   toggleLazyConst,