@effect/language-service 0.16.6 → 0.17.0

package/README.md

@@ -45,6 +45,7 @@ And you're done! You'll now be able to use a set of refactor and diagnostics tha
 ### Completions
 
 - Autocomplete 'Self' in Effect.Service, Context.Tag, Schema.TaggedClass, Schema.TaggedRequest and family
+- Autocomplete Effect.gen with `function*(){}`
 
 ### Refactors
 

package/index.js

@@ -1372,50 +1372,62 @@ var tryPreserveDeclarationSemantics = fn("AST.tryPreserveDeclarationSemantics")(
     return node;
   }
 );
+var parseAccessedExpressionForCompletion = fn(
+  "AST.parseAccessedExpressionForCompletion"
+)(
+  function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
+    if (!precedingToken) return yield* fail(new NodeNotFoundError());
+    let accessedObject = precedingToken;
+    let replacementSpan = ts.createTextSpan(position, 0);
+    let outerNode = precedingToken;
+    if (ts.isIdentifier(precedingToken) && precedingToken.parent && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      replacementSpan = ts.createTextSpan(
+        precedingToken.parent.getStart(sourceFile),
+        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+      );
+      accessedObject = precedingToken.parent.expression;
+      outerNode = precedingToken.parent;
+    } else if (ts.isToken(precedingToken) && precedingToken.kind === ts.SyntaxKind.DotToken && ts.isPropertyAccessExpression(precedingToken.parent)) {
+      replacementSpan = ts.createTextSpan(
+        precedingToken.parent.getStart(sourceFile),
+        precedingToken.end - precedingToken.parent.getStart(sourceFile)
+      );
+      accessedObject = precedingToken.parent.expression;
+      outerNode = precedingToken.parent;
+    } else if (ts.isIdentifier(precedingToken) && precedingToken.parent) {
+      replacementSpan = ts.createTextSpan(
+        precedingToken.getStart(sourceFile),
+        precedingToken.end - precedingToken.getStart(sourceFile)
+      );
+      accessedObject = precedingToken;
+      outerNode = precedingToken;
+    } else {
+      return yield* fail(new NodeNotFoundError());
+    }
+    return { accessedObject, outerNode, replacementSpan };
+  }
+);
 var parseDataForExtendsClassCompletion = fn(
   "AST.parseDataForExtendsClassCompletion"
 )(function* (sourceFile, position) {
   const ts = yield* service(TypeScriptApi);
-  const precedingToken = ts.findPrecedingToken(position, sourceFile, void 0, true);
-  if (!precedingToken) return none2();
-  let accessedObject = precedingToken;
-  let replacementSpan = ts.createTextSpan(position, 0);
-  let outerNode = precedingToken;
-  if (ts.isIdentifier(precedingToken) && precedingToken.parent && ts.isPropertyAccessExpression(precedingToken.parent)) {
-    replacementSpan = ts.createTextSpan(
-      precedingToken.parent.getStart(sourceFile),
-      precedingToken.end - precedingToken.parent.getStart(sourceFile)
-    );
-    accessedObject = precedingToken.parent.expression;
-    outerNode = precedingToken.parent;
-  } else if (ts.isToken(precedingToken) && precedingToken.kind === ts.SyntaxKind.DotToken && ts.isPropertyAccessExpression(precedingToken.parent)) {
-    replacementSpan = ts.createTextSpan(
-      precedingToken.parent.getStart(sourceFile),
-      precedingToken.end - precedingToken.parent.getStart(sourceFile)
-    );
-    accessedObject = precedingToken.parent.expression;
-    outerNode = precedingToken.parent;
-  } else if (ts.isIdentifier(precedingToken) && precedingToken.parent) {
-    replacementSpan = ts.createTextSpan(
-      precedingToken.getStart(sourceFile),
-      precedingToken.end - precedingToken.getStart(sourceFile)
-    );
-    accessedObject = precedingToken;
-    outerNode = precedingToken;
-  } else {
-    return none2();
-  }
-  if (!ts.isIdentifier(accessedObject)) return none2();
+  const { accessedObject, outerNode, replacementSpan } = yield* parseAccessedExpressionForCompletion(sourceFile, position);
+  if (!ts.isIdentifier(accessedObject)) return yield* fail(new NodeNotFoundError());
   let classDeclaration = outerNode.parent;
   while (ts.isExpressionWithTypeArguments(classDeclaration) || ts.isHeritageClause(classDeclaration)) {
     if (!classDeclaration.parent) break;
     classDeclaration = classDeclaration.parent;
   }
-  if (!ts.isClassDeclaration(classDeclaration)) return none2();
-  if (!classDeclaration.name) return none2();
-  return some2(
-    { accessedObject, classDeclaration, className: classDeclaration.name, replacementSpan }
-  );
+  if (!ts.isClassDeclaration(classDeclaration)) return yield* fail(new NodeNotFoundError());
+  if (!classDeclaration.name) return yield* fail(new NodeNotFoundError());
+  return {
+    accessedObject,
+    classDeclaration,
+    className: classDeclaration.name,
+    replacementSpan
+  };
 });
 var createEffectGenCallExpression = fn("AST.createEffectGenCallExpression")(function* (effectModuleIdentifierName, node) {
   const ts = yield* service(TypeScriptApi);
@@ -1647,7 +1659,9 @@ var contextSelfInClasses = createCompletion({
   name: "effect/contextSelfInClasses",
   apply: fn("contextSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* parseDataForExtendsClassCompletion(sourceFile, position);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
     if (isNone2(maybeInfos)) return [];
     const { accessedObject, className, replacementSpan } = maybeInfos.value;
     const contextName = yield* option(
@@ -1678,7 +1692,9 @@ var effectDataClasses = createCompletion({
   name: "effect/effectDataClasses",
   apply: fn("effectDataClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* parseDataForExtendsClassCompletion(sourceFile, position);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
     if (isNone2(maybeInfos)) return [];
     const { accessedObject, className, replacementSpan } = maybeInfos.value;
     const dataName = yield* option(
@@ -1715,7 +1731,9 @@ var effectSchemaSelfInClasses = createCompletion({
   name: "effect/effectSchemaSelfInClasses",
   apply: fn("effectSchemaSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* parseDataForExtendsClassCompletion(sourceFile, position);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
     if (isNone2(maybeInfos)) return [];
     const { accessedObject, className, replacementSpan } = maybeInfos.value;
     const effectSchemaName = yield* option(
@@ -1764,7 +1782,9 @@ var effectSelfInClasses = createCompletion({
   name: "effect/effectSelfInClasses",
   apply: fn("effectSelfInClasses")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
-    const maybeInfos = yield* parseDataForExtendsClassCompletion(sourceFile, position);
+    const maybeInfos = yield* option(
+      parseDataForExtendsClassCompletion(sourceFile, position)
+    );
     if (isNone2(maybeInfos)) return [];
     const { accessedObject, className, replacementSpan } = maybeInfos.value;
     const effectName = yield* option(
@@ -1790,14 +1810,6 @@ var effectSelfInClasses = createCompletion({
   })
 });
 
-// src/completions.ts
-var completions = [
-  effectSchemaSelfInClasses,
-  effectSelfInClasses,
-  contextSelfInClasses,
-  effectDataClasses
-];
-
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag("TypeChecker");
 var TypeCheckerApiCache = Tag("TypeCheckerApiCache");
@@ -2004,6 +2016,45 @@ var expectedAndRealType = fn("TypeCheckerApi.expectedAndRealType")(function* (so
   return result;
 });
 
+// src/completions/genFunctionStar.ts
+var genFunctionStar = createCompletion({
+  name: "effect/genFunctionStar",
+  apply: fn("genFunctionStar")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const maybeInfos = yield* option(
+      parseAccessedExpressionForCompletion(sourceFile, position)
+    );
+    if (isNone2(maybeInfos)) return [];
+    const { accessedObject } = maybeInfos.value;
+    const type = typeChecker.getTypeAtLocation(accessedObject);
+    const genMemberSymbol = type.getProperty("gen");
+    if (!genMemberSymbol) return [];
+    const genType = typeChecker.getTypeOfSymbolAtLocation(genMemberSymbol, accessedObject);
+    if (genType.getCallSignatures().length === 0) return [];
+    const span = ts.createTextSpan(
+      accessedObject.end + 1,
+      Math.max(0, position - accessedObject.end - 1)
+    );
+    return [{
+      name: `gen(function*(){})`,
+      kind: ts.ScriptElementKind.constElement,
+      insertText: `gen(function*(){${"${0}"}})`,
+      replacementSpan: span,
+      isSnippet: true
+    }];
+  })
+});
+
+// src/completions.ts
+var completions = [
+  effectSchemaSelfInClasses,
+  effectSelfInClasses,
+  contextSelfInClasses,
+  genFunctionStar,
+  effectDataClasses
+];
+
 // src/utils/TypeParser.ts
 var TypeParserIssue = class {
   constructor(type, node, message) {
@@ -3707,7 +3758,7 @@ var createUnsupportedNodeComment = (ts, sourceFile, node) => ts.addSyntheticTrai
   ts.SyntaxKind.MultiLineCommentTrivia,
   " Not supported conversion: " + node.getText(sourceFile) + " "
 );
-var processNode = (node) => gen2(function* () {
+var processNode = (node, isVirtualTypeNode) => gen2(function* () {
   const { createApiCall, createApiPropertyAccess, entityNameToDataTypeName, sourceFile, ts } = yield* service(
     SchemaGenContext
   );
@@ -3741,12 +3792,12 @@ var processNode = (node) => gen2(function* () {
   if (ts.isUnionTypeNode(node)) {
     const allLiterals = yield* option(parseAllLiterals(node));
     if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
-    const members = yield* all2(...node.types.map((_) => processNode(_)));
+    const members = yield* all2(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
     return createApiCall("Union", members);
   }
   if (ts.isIntersectionTypeNode(node)) {
     const [firstSchema, ...otherSchemas] = yield* all2(
-      ...node.types.map((_) => processNode(_))
+      ...node.types.map((_) => processNode(_, isVirtualTypeNode))
     );
     if (otherSchemas.length === 0) return firstSchema;
     return ts.factory.createCallExpression(
@@ -3760,22 +3811,28 @@ var processNode = (node) => gen2(function* () {
   }
   if (ts.isTypeOperatorNode(node)) {
     if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
-      return createApiCall("keyof", [yield* processNode(node.type)]);
+      return createApiCall("keyof", [yield* processNode(node.type, isVirtualTypeNode)]);
     } else if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
-      return yield* processNode(node.type);
+      return yield* processNode(node.type, isVirtualTypeNode);
     }
   }
   if (ts.isArrayTypeNode(node)) {
-    const typeSchema = yield* processNode(node.elementType);
+    const typeSchema = yield* processNode(node.elementType, isVirtualTypeNode);
     return createApiCall("Array", [typeSchema]);
   }
   if (ts.isTypeLiteralNode(node)) {
-    const { properties, records } = yield* processMembers(node.members);
+    const { properties, records } = yield* processMembers(node.members, isVirtualTypeNode);
     return createApiCall(
       "Struct",
       [ts.factory.createObjectLiteralExpression(properties, true)].concat(records)
     );
   }
+  if (ts.isTypeQueryNode(node)) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const type = typeChecker.getTypeAtLocation(node.exprName);
+    const typeNode = typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation);
+    if (typeNode) return yield* processNode(typeNode, true);
+  }
   if (ts.isTypeReferenceNode(node)) {
     const parsedName = entityNameToDataTypeName(node.typeName);
     if (isSome2(parsedName)) {
@@ -3787,13 +3844,13 @@ var processNode = (node) => gen2(function* () {
         case "Chunk":
         case "Array": {
           const elements = yield* all2(
-            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+            ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           return createApiCall(parsedName.value, elements);
         }
         case "Record": {
           const elements = yield* all2(
-            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+            ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
             return createApiCall(parsedName.value, [
@@ -3807,7 +3864,7 @@ var processNode = (node) => gen2(function* () {
         }
         case "Either": {
           const elements = yield* all2(
-            ...node.typeArguments ? node.typeArguments.map(processNode) : []
+            ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
             return createApiCall(parsedName.value, [
@@ -3825,7 +3882,7 @@ var processNode = (node) => gen2(function* () {
           if (typeArguments.length !== 2) {
             return createUnsupportedNodeComment(ts, sourceFile, node);
           }
-          const baseType = yield* processNode(typeArguments[0]);
+          const baseType = yield* processNode(typeArguments[0], isVirtualTypeNode);
           const stringLiteralArguments = yield* option(parseAllLiterals(typeArguments[1]));
           if (isNone2(stringLiteralArguments)) {
             return createUnsupportedNodeComment(ts, sourceFile, node);
@@ -3852,7 +3909,7 @@ var processNode = (node) => gen2(function* () {
 var processMembers = fn(
   "SchemaGen.processMembers"
 )(
-  function* (members) {
+  function* (members, isVirtualTypeNode) {
     const { createApiCall, ts } = yield* service(
       SchemaGenContext
     );
@@ -3866,7 +3923,7 @@ var processMembers = fn(
         return yield* fail(new RequiredExplicitTypesError(propertySignature));
       }
       const propertyAssignment = pipe(
-        yield* processNode(propertySignature.type),
+        yield* processNode(propertySignature.type, isVirtualTypeNode),
         propertySignature.questionToken ? (_) => createApiCall("optional", [_]) : identity,
         (_) => ts.factory.createPropertyAssignment(name, _)
       );
@@ -3880,8 +3937,8 @@ var processMembers = fn(
       const parameter = indexSignature.parameters[0];
       if (!parameter.type) return yield* fail(new RequiredExplicitTypesError(parameter));
       const parameterType = parameter.type;
-      const key = yield* processNode(parameterType);
-      const value = yield* processNode(indexSignature.type);
+      const key = yield* processNode(parameterType, isVirtualTypeNode);
+      const value = yield* processNode(indexSignature.type, isVirtualTypeNode);
       records.push(
         ts.factory.createObjectLiteralExpression([
           ts.factory.createPropertyAssignment("key", key),
@@ -3900,7 +3957,7 @@ var processInterfaceDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
     const { createApiCall, ts } = yield* service(
       SchemaGenContext
     );
-    const { properties, records } = yield* processMembers(node.members);
+    const { properties, records } = yield* processMembers(node.members, false);
     if (preferClass && records.length === 0) {
       return yield* createExportSchemaClassDeclaration(node.name.text, properties);
     }
@@ -3918,12 +3975,12 @@ var processTypeAliasDeclaration = fn("SchemaGen.processInterfaceDeclaration")(
       return yield* fail(new TypeParametersNotSupportedError(node));
     }
     if (preferClass && ts.isTypeLiteralNode(node.type)) {
-      const { properties, records } = yield* processMembers(node.type.members);
+      const { properties, records } = yield* processMembers(node.type.members, false);
       if (records.length === 0) {
         return yield* createExportSchemaClassDeclaration(node.name.text, properties);
       }
     }
-    const effectSchema = yield* processNode(node.type);
+    const effectSchema = yield* processNode(node.type, false);
     return yield* createExportVariableDeclaration(node.name.text, effectSchema);
   }
 );
@@ -4026,6 +4083,7 @@ var typeToEffectSchema = createRefactor({
   description: "Refactor to Schema",
   apply: fn("typeToEffectSchema.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -4034,6 +4092,7 @@ var typeToEffectSchema = createRefactor({
       description: "Refactor to Schema",
       apply: pipe(
         applyAtNode(sourceFile, node, false),
+        provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptApi, ts)
       )
     };
@@ -4046,6 +4105,7 @@ var typeToEffectSchemaClass = createRefactor({
   description: "Refactor to Schema.Class",
   apply: fn("typeToEffectSchemaClass.apply")(function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
     const maybeNode = yield* findNodeToProcess(sourceFile, textRange);
     if (isNone2(maybeNode)) return yield* fail(new RefactorNotApplicableError());
     const node = maybeNode.value;
@@ -4054,6 +4114,7 @@ var typeToEffectSchemaClass = createRefactor({
       description: "Refactor to Schema.Class",
       apply: pipe(
         applyAtNode(sourceFile, node, true),
+        provideService(TypeCheckerApi, typeChecker),
         provideService(TypeScriptApi, ts)
       )
     };